@quatrain/core 0.5.6 → 1.0.0-beta10

package/lib/components/DataObject.d.ts

@@ -3,6 +3,7 @@ import { PropertyClassType } from '../properties/types/PropertyClassType';
 import { AbstractObject } from './AbstractObject';
 import { ObjectUri } from './ObjectUri';
 import { DataObjectClass } from './types/DataObjectClass';
+import { toJSONParams } from './types/toJSONParams';
 export type CoreObject<T extends AbstractObject> = T;
 export type Properties = {
     [x: string]: PropertyClassType;
@@ -14,6 +15,7 @@ export interface DataObjectFactoryType {
 export interface DataObjectParams {
     uri?: string | ObjectUri;
     properties: DataObjectProperties;
+    parentProp?: string;
 }
 /**
  * Data objects constitute the agnostic glue between objects and backends.
@@ -26,6 +28,8 @@ export declare class DataObject implements DataObjectClass<any> {
     protected _properties: Properties;
     protected _persisted: boolean;
     protected _populated: boolean;
+    protected _parentProp: string | undefined;
+    protected _proxied: any;
     /**
      * Has data been modified since last backend operation?
      */
@@ -36,7 +40,19 @@ export declare class DataObject implements DataObjectClass<any> {
      */
     protected constructor(params: DataObjectParams | undefined);
     protected _init(properties: any[]): void;
+    /**
+     * Wrap instance into proxy to get access to properties
+     * @returns Proxy
+     */
+    asProxy(): this;
     setProperties(properties: Properties): void;
+    /**
+     * Return a map of all propoerties or only those matching the provided type
+     * @param type
+     * @returns
+     */
+    getProperties(type?: string): {};
+    addProperty(property: PropertyClassType): void;
     /**
      * Populate data object from instant data or backend query
      * @param data
@@ -68,6 +84,7 @@ export declare class DataObject implements DataObjectClass<any> {
     set uri(uri: ObjectUri);
     get uri(): ObjectUri;
     get class(): any;
+    get parentProp(): string | undefined;
     has(key: string): boolean;
     /**
      * Returns property matching key or throw
@@ -81,8 +98,8 @@ export declare class DataObject implements DataObjectClass<any> {
      * @param key string
      * @returns any
      */
-    val(key: string): any;
-    toJSON(objectsAsReferences?: boolean): {
+    val(key: string, transform?: string | undefined): any;
+    toJSON(params?: boolean | toJSONParams): {
         [x: string]: any;
     };
     toReference(): {
@@ -90,7 +107,7 @@ export declare class DataObject implements DataObjectClass<any> {
         ref: string;
         uri: string;
     };
-    protected _dataToJSON(objectsAsReferences?: boolean): {};
+    protected _dataToJSON(objectsAsReferences?: boolean, ignoreUnchanged?: boolean, converters?: {}): {};
     read(): Promise<DataObjectClass<any>>;
     save(): Promise<DataObjectClass<any>>;
     delete(): Promise<DataObjectClass<any>>;

package/lib/components/DataObject.js

@@ -13,6 +13,7 @@ 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");
 /**
  * Data objects constitute the agnostic glue between objects and backends.
  * They handle data and identifiers in a protected registry
@@ -39,6 +40,7 @@ class DataObject {
             else {
                 this._objectUri = params.uri;
             }
+            this._parentProp = params.parentProp;
         }
         else {
             this._objectUri = new ObjectUri_1.ObjectUri();
@@ -52,10 +54,51 @@ class DataObject {
             this._properties[prop.name] = Property_1.Property.factory(prop, this);
         });
     }
+    /**
+     * Wrap instance into proxy to get access to properties
+     * @returns Proxy
+     */
+    asProxy() {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                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;
+            },
+        });
+    }
     setProperties(properties) {
         // TODO check if doable
         this._properties = properties;
     }
+    /**
+     * Return a map of all propoerties or only those matching the provided type
+     * @param type
+     * @returns
+     */
+    getProperties(type) {
+        if (type) {
+            const matches = {};
+            for (let k of Object.keys(this._properties)) {
+                if (this._properties[k].constructor.name === type) {
+                    Reflect.set(matches, k, this._properties[k]);
+                }
+            }
+            return matches;
+        }
+        return this._properties;
+    }
+    addProperty(property) {
+        if (Object.keys(this._properties).includes(property.name)) {
+            throw new Error(`Property ${property.name} already exists`);
+        }
+        this._properties[property.name] = property;
+    }
     /**
      * Populate data object from instant data or backend query
      * @param data
@@ -93,10 +136,10 @@ class DataObject {
                         'label' in val &&
                         typeof val.label == 'string') {
                         const { ref, label } = val;
-                        Reflect.get(this._properties, key).set(new ObjectUri_1.ObjectUri(ref, label));
+                        Reflect.get(this._properties, key).set(new ObjectUri_1.ObjectUri(ref, label), false);
                     }
                     else {
-                        Reflect.get(this._properties, key).set(data[key]);
+                        Reflect.get(this._properties, key).set(data[key], false);
                     }
                 }
             }
@@ -165,6 +208,9 @@ class DataObject {
         // TODO get class type
         return this.uri.class;
     }
+    get parentProp() {
+        return this._parentProp;
+    }
     has(key) {
         return Reflect.has(this._properties, key);
     }
@@ -174,12 +220,10 @@ class DataObject {
      * @returns BaseProperty
      */
     get(key) {
-        try {
-            return this._properties[key];
-        }
-        catch (err) {
-            throw new Error(err.message);
+        if (!Reflect.has(this._properties, key)) {
+            throw new ResourcesErrors_1.NotFoundError(`No property matching key '${key}'`);
         }
+        return Reflect.get(this._properties, key);
     }
     set(key, val) {
         if (!this.has(key)) {
@@ -195,24 +239,36 @@ class DataObject {
      * @param key string
      * @returns any
      */
-    val(key) {
+    val(key, transform = undefined) {
         if (this.has(key)) {
-            return Reflect.get(this._properties, key).val();
+            return Reflect.get(this._properties, key).val(transform);
         }
         else {
             throw new Error(`Unknown property '${key}'`);
         }
     }
-    toJSON(objectsAsReferences = false) {
-        return Object.assign(Object.assign({}, (this._uid && { uid: this._uid })), this._dataToJSON(objectsAsReferences));
+    toJSON(params = false) {
+        let objectsAsReferences = false, withoutURIData = false, ignoreUnchanged = false, converters = {};
+        if (typeof params === 'object') {
+            // Any missing parameter should resolve to false
+            objectsAsReferences = Boolean(params.objectsAsReferences);
+            withoutURIData = Boolean(params.withoutURIData);
+            ignoreUnchanged = Boolean(params.ignoreUnchanged);
+            converters = params.converters;
+        }
+        return Object.assign(Object.assign({}, (!withoutURIData &&
+            this.uri && { uid: this.uri.uid, path: this.uri.path })), this._dataToJSON(objectsAsReferences, ignoreUnchanged, converters));
     }
     toReference() {
         return Object.assign(Object.assign({}, this._objectUri.toReference()), { label: this.val('name') || '' });
     }
-    _dataToJSON(objectsAsReferences = false) {
+    _dataToJSON(objectsAsReferences = false, ignoreUnchanged = false, converters = {}) {
         const data = {};
         Object.keys(this._properties).forEach((key) => {
             const prop = Reflect.get(this._properties, key);
+            if (ignoreUnchanged && prop.hasChanged === false)
+                return;
+            //   console.log(prop.constructor.name);
             switch (prop.constructor.name) {
                 case 'CollectionProperty':
                     // ignore
@@ -221,7 +277,7 @@ class DataObject {
                     const value = prop.val();
                     Reflect.set(data, key, value
                         ? objectsAsReferences && !(value instanceof ObjectUri_1.ObjectUri)
-                            ? value.core.asReference()
+                            ? value.asReference()
                             : value.toJSON
                                 ? value.toJSON()
                                 : value
@@ -233,8 +289,12 @@ class DataObject {
                 case 'ArrayProperty':
                     Reflect.set(data, key, prop.val() || []);
                     break;
+                case 'DateTimeProperty':
+                    Reflect.set(data, key, prop.val(Reflect.get(converters, 'datetime')) || null);
+                    break;
                 default:
                     Reflect.set(data, key, prop.val() || null);
+                    break;
             }
         });
         return data;

package/lib/components/Entity.d.ts

@@ -1,26 +1,9 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-import { User, UserCore } from './User';
-import { EntityClass } from './types/EntityClass';
-export declare const EntityProperties: any;
-export interface Entity extends BaseObject {
-    users: User;
+export interface EntityType extends BaseObject {
 }
-export declare class EntityCore extends BaseObjectCore implements EntityClass {
+export declare class Entity extends BaseObjectCore {
     static COLLECTION: string;
-    static PROPS_DEFINITION: ({
-        name: string;
-        type: string;
-        mandatory: boolean;
-        minLength: number;
-        instanceOf?: undefined;
-        parentKey?: undefined;
-    } | {
-        name: string;
-        mandatory: boolean;
-        type: string;
-        instanceOf: typeof UserCore;
-        parentKey: string;
-        minLength?: undefined;
-    })[];
+    static PROPS_DEFINITION: any[];
+    static factory(src?: any): Promise<Entity>;
 }

package/lib/components/Entity.js

@@ -22,48 +22,50 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityCore = exports.EntityProperties = void 0;
+exports.Entity = void 0;
 const BaseObjectCore_1 = require("./BaseObjectCore");
-const User_1 = require("./User");
-const CollectionProperty_1 = require("../properties/CollectionProperty");
+const BaseObject_1 = require("./BaseObject");
+//import { User } from './User'
+//import { CollectionProperty } from '../properties/CollectionProperty'
 const StringProperty_1 = require("../properties/StringProperty");
 const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
-exports.EntityProperties = [
-    {
-        // surcharge property minLength and htmlType
-        name: 'name',
-        type: StringProperty_1.StringProperty.TYPE,
-        mandatory: true,
-        minLength: 1,
-        htmlType: htmlType.ORG,
-    },
-    {
-        name: 'users',
-        mandatory: true,
-        type: CollectionProperty_1.CollectionProperty.TYPE,
-        instanceOf: 'User',
-        parentKey: 'entity',
-    },
-];
-class EntityCore extends BaseObjectCore_1.BaseObjectCore {
+class Entity extends BaseObjectCore_1.BaseObjectCore {
+    static factory(src = undefined) {
+        const _super = Object.create(null, {
+            factory: { get: () => super.factory }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.factory.call(this, src, Entity);
+        });
+    }
 }
-exports.EntityCore = EntityCore;
-EntityCore.COLLECTION = 'entity';
-EntityCore.PROPS_DEFINITION = [
+exports.Entity = Entity;
+Entity.COLLECTION = 'entities';
+Entity.PROPS_DEFINITION = [
+    ...BaseObject_1.BaseObjectProperties,
     {
         // surcharge property minLength and htmlType
         name: 'name',
         type: StringProperty_1.StringProperty.TYPE,
         mandatory: true,
         minLength: 1,
-        //htmlType: htmlType.ORG,
-    },
-    {
-        name: 'users',
-        mandatory: true,
-        type: CollectionProperty_1.CollectionProperty.TYPE,
-        instanceOf: User_1.UserCore,
-        parentKey: 'entity',
+        htmlType: htmlType.ORG,
     },
+    // {
+    //    name: 'users',
+    //    mandatory: true,
+    //    type: CollectionProperty.TYPE,
+    //    instanceOf: User,
+    //    parentKey: 'entity',
+    // },
 ];

package/lib/components/EntityRepository.d.ts

@@ -1,6 +1,6 @@
-import { BackendInterface } from '../backends';
+import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
-import { Entity } from './Entity';
-export default class EntityRepository extends BaseRepository<Entity> {
+import { EntityType } from './Entity';
+export default class EntityRepository extends BaseRepository<EntityType> {
     constructor(backendAdapter?: BackendInterface);
 }

package/lib/components/EntityRepository.js

@@ -8,7 +8,7 @@ const BaseRepository_1 = __importDefault(require("./BaseRepository"));
 const Entity_1 = require("./Entity");
 class EntityRepository extends BaseRepository_1.default {
     constructor(backendAdapter = Core_1.Core.getBackend()) {
-        super(Entity_1.EntityCore, backendAdapter);
+        super(Entity_1.Entity, backendAdapter);
     }
 }
 exports.default = EntityRepository;

package/lib/components/ObjectUri.js

@@ -48,14 +48,13 @@ class ObjectUri {
             this._label = label || this._uid;
         }
         else {
-            throw new Error('Path parts number must be 1 or even');
+            throw new Error(`Path parts number must be 1 or even, received: '${str}'`);
         }
     }
     set class(objClass) {
-        var _a;
         this._objClass = objClass;
         if (objClass) {
-            this._collection = objClass.COLLECTION || ((_a = objClass.name) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+            this._collection = objClass.COLLECTION || objClass.name && objClass.name.toLowerCase();
         }
         else {
             this._collection = undefined;

package/lib/components/User.d.ts

@@ -1,8 +1,7 @@
 import { BaseObjectCore } from './BaseObjectCore';
 import { BaseObject } from './BaseObject';
-import { Persisted } from './types/Persisted';
-import { Proxy } from './types/ProxyConstructor';
-export interface User extends BaseObject {
+export interface UserType extends BaseObject {
+    name: string;
     firstname: string;
     lastname: string;
     gender?: 'male' | 'female' | 'nonbinary';
@@ -11,8 +10,8 @@ export interface User extends BaseObject {
     email: string;
 }
 export declare const UserProperties: any;
-export declare class UserCore extends BaseObjectCore {
+export declare class User extends BaseObjectCore {
     static PROPS_DEFINITION: any;
     static COLLECTION: string;
-    static factory(src?: any): Promise<Proxy<User> | Persisted<User>>;
+    static factory(src?: any): Promise<User>;
 }

package/lib/components/User.js

@@ -32,13 +32,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserCore = exports.UserProperties = void 0;
+exports.User = exports.UserProperties = void 0;
 const BaseObjectCore_1 = require("./BaseObjectCore");
 const properties_1 = require("../properties");
 const HashProperty_1 = require("../properties/HashProperty");
 const StringProperty_1 = require("../properties/StringProperty");
 const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
 const BaseObject_1 = require("./BaseObject");
+const Entity_1 = require("./Entity");
 /**
  * Callback function to populate the 'name' property
  * @param dao DataObject
@@ -52,7 +53,6 @@ exports.UserProperties = [
         name: 'name',
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 0,
-        fullSearch: true,
         htmlType: htmlType.NAME,
     },
     {
@@ -61,6 +61,7 @@ exports.UserProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.GIVEN_NAME,
         onChange,
     },
@@ -70,6 +71,7 @@ exports.UserProperties = [
         type: StringProperty_1.StringProperty.TYPE,
         minLength: 1,
         maxLength: 100,
+        fullSearch: true,
         htmlType: htmlType.FAMILY_NAME,
         onChange,
     },
@@ -95,33 +97,40 @@ exports.UserProperties = [
         fullSearch: true,
         htmlType: htmlType.EMAIL,
     },
+    {
+        name: 'phone',
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        htmlType: htmlType.OFF,
+    },
     {
         name: 'password',
         mandatory: true,
         type: HashProperty_1.HashProperty.TYPE,
         algorithm: HashProperty_1.HashProperty.ALGORITHM_SHA256,
-        salt: '',
+        salt: '', // you should override it in your code
         minLength: 5,
-        maxLength: 20,
+        maxLength: 20, // this is for the clear password
         htmlType: htmlType.PASSWORD,
     },
     {
         name: 'entity',
         mandatory: false,
         type: properties_1.ObjectProperty.TYPE,
-        instanceOf: BaseObjectCore_1.BaseObjectCore,
+        instanceOf: Entity_1.Entity,
     },
 ];
-class UserCore extends BaseObjectCore_1.BaseObjectCore {
+class User extends BaseObjectCore_1.BaseObjectCore {
     static factory(src = undefined) {
         const _super = Object.create(null, {
             factory: { get: () => super.factory }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            return _super.factory.call(this, src, UserCore);
+            return _super.factory.call(this, src, User);
         });
     }
 }
-exports.UserCore = UserCore;
-UserCore.PROPS_DEFINITION = exports.UserProperties;
-UserCore.COLLECTION = 'user';
+exports.User = User;
+User.PROPS_DEFINITION = exports.UserProperties;
+User.COLLECTION = 'user';

package/lib/components/UserRepository.d.ts

@@ -1,7 +1,7 @@
-import { BackendInterface } from '../backends';
+import { BackendInterface } from '../backends/types/BackendInterface';
 import BaseRepository from './BaseRepository';
-import { User } from './User';
-export default class UserRepository extends BaseRepository<User> {
+import { UserType } from './User';
+export default class UserRepository extends BaseRepository<UserType> {
     constructor(backendAdapter?: BackendInterface);
-    getFromEmail(email: string): Promise<import("./types/Persisted").Persisted<import("./types/Persisted").Persisted<User>>>;
+    getFromEmail(email: string): Promise<UserType>;
 }

package/lib/components/UserRepository.js

@@ -19,11 +19,11 @@ const User_1 = require("./User");
 const UNAUTHORIZED_ERROR = `Wrong password or email`;
 class UserRepository extends BaseRepository_1.default {
     constructor(backendAdapter) {
-        super(User_1.UserCore, backendAdapter);
+        super(User_1.User, backendAdapter);
     }
     getFromEmail(email) {
         return __awaiter(this, void 0, void 0, function* () {
-            const query = new backends_1.Query(User_1.UserCore);
+            const query = new backends_1.Query(User_1.User);
             query.where('email', email).batch(1);
             const { items } = yield this.query(query);
             if (items.length == 0) {

package/lib/components/index.d.ts

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

package/lib/components/index.js

@@ -1,6 +1,9 @@
 "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.UserCore = exports.BaseObjectCore = exports.AbstractObject = exports.ObjectUri = exports.DataObject = void 0;
+exports.UserProperties = exports.BaseObjectProperties = exports.Entity = exports.User = exports.BaseRepository = exports.BaseObjectCore = 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");
@@ -11,6 +14,10 @@ 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, "UserCore", { enumerable: true, get: function () { return User_1.UserCore; } });
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return User_1.User; } });
 Object.defineProperty(exports, "UserProperties", { enumerable: true, get: function () { return User_1.UserProperties; } });
+const Entity_1 = require("./Entity");
+Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return Entity_1.Entity; } });

package/lib/components/types/DataObjectClass.d.ts

@@ -1,4 +1,6 @@
+import { PropertyClassType } from '../../properties/types/PropertyClassType';
 import { ObjectUri } from '../ObjectUri';
+import { toJSONParams } from './toJSONParams';
 export interface DataObjectClass<T extends DataObjectClass<any>> {
     uri: ObjectUri;
     uid: any;
@@ -6,7 +8,10 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     path: any;
     class: any;
     properties: any;
+    parentProp: string | undefined;
     setProperties(properties: any): void;
+    getProperties(type: any): any;
+    addProperty(property: PropertyClassType): void;
     populate(data?: any): Promise<T>;
     isPopulated(): boolean;
     isPersisted(): boolean;
@@ -19,8 +24,9 @@ export interface DataObjectClass<T extends DataObjectClass<any>> {
     delete(): Promise<T>;
     clone(data?: any): Promise<T>;
     toReference(): any;
-    toJSON(objectsAsReferences?: boolean): any;
+    toJSON(params?: boolean | toJSONParams): any;
     populateFromData(data: {
         [x: string]: unknown;
     }): this;
+    asProxy(): any;
 }

package/lib/components/types/RepositoryClass.d.ts

@@ -1,4 +1,4 @@
-import { BackendInterface } from '../../backends/AbstractAdapter';
+import { BackendInterface } from '../../backends/types/BackendInterface';
 import { Query } from '../../backends/Query';
 import { BaseObjectCore } from '../BaseObjectCore';
 import { BaseObject } from '../BaseObject';
@@ -18,7 +18,7 @@ export default interface RepositoryClass<T extends BaseObject> {
      * @param uid
      * @returns
      */
-    read(uid: string): Promise<Persisted<T>>;
+    read(uid: string): Promise<any>;
     /**
      * Updates a given object in the collction and returns it
      * @param obj

package/lib/components/types/toJSONParams.d.ts

@@ -0,0 +1,8 @@
+export type toJSONParams = {
+    objectsAsReferences?: boolean;
+    withoutURIData?: boolean;
+    ignoreUnchanged?: boolean;
+    converters?: {
+        [propType: string]: Function;
+    };
+};

package/lib/components/types/toJSONParams.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -17,13 +17,18 @@ 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 AbstractRepository from './components/BaseRepository';
+import BaseRepository from './components/BaseRepository';
+import { BackendAction, BackendParameters, BackendParametersKeys, BackendRecordType } from './Backend';
 import Middleware from './backends/middlewares/Middleware';
-import { User } from './components/User';
+import { UserType, User } from './components/User';
 import UserRepository from './components/UserRepository';
-import { Entity } from './components/Entity';
+import { EntityType, Entity } from './components/Entity';
 import EntityRepository from './components/EntityRepository';
-import { AbstractAdapter, MockAdapter, BackendError, BackendParameters, Query, Filter, Filters, Limits, Sorting, SortAndLimit } from './backends';
+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';
-export { statuses, utils, Core, Property, BaseProperty, BasePropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, HashProperty, HashPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, AbstractAdapter, RepositoryClass, AbstractRepository, MockAdapter, ObjectUri, DataObjectClass, DataObject, AbstractObject, BaseObject, BaseObjectCore, BaseObjectProperties, BackendParameters, BackendError, Query, Filter, Filters, Limits, Sorting, SortAndLimit, Middleware, InjectMetaMiddleware, User, Proxy, UserRepository, Entity, EntityRepository, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, GoneError, };
+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, AbstractCloudWrapper, };