@quatrain/core 1.0.0-beta22 → 1.0.0-beta23

package/lib/Backend copy.d.ts

@@ -0,0 +1,39 @@
+import Middleware from './backends/middlewares/Middleware';
+export declare enum BackendAction {
+    CREATE = "create",
+    READ = "read",
+    UPDATE = "update",
+    DELETE = "delete",
+    WRITE = "write"
+}
+/**
+ * Default interface for a backend record
+ */
+export interface BackendRecordType {
+    uid: string | undefined;
+    path: string | undefined;
+    [key: string]: any;
+}
+/**
+ * Backend Parameters acceptable keys
+ */
+export type BackendParametersKeys = 'host' | 'alias' | 'mapping' | 'middlewares' | 'config' | 'fixtures' | 'softDelete' | 'debug';
+/**
+ * Backend parameters interface
+ */
+export interface BackendParameters {
+    host?: string;
+    alias?: string;
+    hierarchy?: {
+        [collection: string]: any;
+    };
+    mapping?: {
+        [x: string]: any;
+    };
+    middlewares?: Middleware[];
+    config?: any;
+    fixtures?: any;
+    softDelete?: boolean;
+    useNativeForeignKeys?: boolean;
+    debug?: boolean;
+}

package/lib/Backend copy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendAction = void 0;
+var BackendAction;
+(function (BackendAction) {
+    BackendAction["CREATE"] = "create";
+    BackendAction["READ"] = "read";
+    BackendAction["UPDATE"] = "update";
+    BackendAction["DELETE"] = "delete";
+    BackendAction["WRITE"] = "write";
+})(BackendAction || (exports.BackendAction = BackendAction = {}));

package/lib/Core.d.ts

@@ -1,10 +1,14 @@
 import { AbstractAuthAdapter } from './authentication';
 import { AbstractAdapter } from './backends/AbstractAdapter';
+import { AbstractStorageAdapter } from './storages';
 import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
 export type BackendRegistry<T extends AbstractAdapter> = {
     [x: string]: T;
 };
+export type StorageBackendRegistry<T extends AbstractStorageAdapter> = {
+    [x: string]: T;
+};
 export interface AuthAdapter extends AbstractAuthAdapter {
 }
 export declare class Core {
@@ -20,7 +24,7 @@ export declare class Core {
     static auth: AuthAdapter | AbstractAuthAdapter;
     static timestamp: () => string;
     protected static _backends: BackendRegistry<any>;
-    protected static _storages: BackendRegistry<any>;
+    protected static _storages: StorageBackendRegistry<any>;
     static definition(key: string): {
         manifest: {
             type: StringConstructor;
@@ -31,8 +35,8 @@ export declare class Core {
     static getConfig(key: string): Promise<any>;
     static addBackend(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
     static getBackend<T extends AbstractAdapter>(alias?: string): T;
-    static addStorage(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
-    static getStorage<T extends AbstractAdapter>(alias?: string): T;
+    static addStorage(backend: AbstractStorageAdapter, alias: string, setDefault?: boolean): void;
+    static getStorage<T extends AbstractStorageAdapter>(alias?: string): T;
     static addClass(name: string, obj: any): void;
     static getClass(name: string): any;
     /**

package/lib/Core.js

@@ -23,13 +23,17 @@ class Core {
     }
     static addConfig(key, value) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.storage.init( /* options ... */);
+            if (!this.storage.set) {
+                yield this.storage.init();
+            }
             yield this.storage.set(`${this.storagePrefix}_${key}`, value);
         });
     }
     static getConfig(key) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.storage.init( /* options ... */);
+            if (!this.storage.get) {
+                yield this.storage.init();
+            }
             return yield this.storage.get(`${this.storagePrefix}_${key}`);
         });
     }

package/lib/Storage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Backend Parameters acceptable keys
+ */
+export type StorageParametersKeys = 'region' | 'alias' | 'config' | 'debug';
+/**
+ * Backend parameters interface
+ */
+export interface StorageParameters {
+    region?: string;
+    alias?: string;
+    config?: any;
+    debug?: boolean;
+}

package/lib/Storage.js

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

package/lib/backends/Query.d.ts

@@ -15,6 +15,7 @@ export type QueryMetaType = {
     executionTime: string | number;
     sortField?: string;
     sortOrder?: 'asc' | 'desc';
+    debug?: any;
 };
 export type QueryResultType<T> = {
     items: Array<T>;

package/lib/backends/Query.js

@@ -54,7 +54,7 @@ class Query {
         else {
             if (operator === 'equals' && Array.isArray(value)) {
                 // auto-convert operator if value is an array
-                operator = 'contains'; // Any'
+                operator = 'contains';
             }
             this.filters.push(new Filter_1.Filter(param, value, operator));
         }
@@ -107,8 +107,6 @@ class Query {
     }
     execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend(this._obj.DEFAULT_BACKEND)) {
         return __awaiter(this, void 0, void 0, function* () {
-            //<DataObjectClass<any>[] | ObjectUri[] | Persisted<BaseObject>[]> {
-            //</any><Array<T2> | Array<DataObject> | Array<ObjectUri>> {
             try {
                 switch (as) {
                     case exports.AS_DATAOBJECTS:

package/lib/components/BaseRepository.js

@@ -76,6 +76,9 @@ class BaseRepository {
     }
     read(key) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!key) {
+                throw new Error(`Missing key value in ${this.constructor.name}`);
+            }
             try {
                 let dataObject;
                 if (key.split('/').length <= 2) {

package/lib/index.d.ts

@@ -30,6 +30,7 @@ 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 { StorageParameters, StorageParametersKeys } from './Storage';
 import { AbstractStorageAdapter } from './storages/AbstractStorageAdapter';
 import { FileType } from './storages/types/FileType';
 import { BlobType } from './storages/types/BlobType';
@@ -37,6 +38,7 @@ import { BlobMediaType } from './storages/types/BlobMediaType';
 import { StorageAdapterInterface } from './storages/StorageAdapterInterface';
 import { FileResponseLink } from './storages/types/FileResponseLink';
 import { FileResponseUrl } from './storages/types/FileResponseUrl';
+import { DownloadFileMeta } from './storages/types/DownloadFileMetaType';
 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, FileType, BlobType, BlobMediaType, StorageAdapterInterface, AbstractStorageAdapter, FileResponseLink, FileResponseUrl, DatabaseTriggerType, 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, StorageParameters, StorageParametersKeys, FileType, BlobType, BlobMediaType, StorageAdapterInterface, AbstractStorageAdapter, FileResponseLink, FileResponseUrl, DownloadFileMeta, DatabaseTriggerType, AbstractCloudWrapper, };

package/lib/properties/FileProperty.d.ts

@@ -0,0 +1,10 @@
+import { ObjectUri } from '../components/ObjectUri';
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+import { BaseObjectClass } from '../components/types/BaseObjectClass';
+export interface FilePropertyType extends BasePropertyType {
+}
+export declare class FileProperty extends BaseProperty {
+    static TYPE: string;
+    _value: BaseObjectClass | ObjectUri | undefined;
+    constructor(config: FilePropertyType);
+}

package/lib/properties/FileProperty.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProperty = void 0;
+const BaseProperty_1 = require("./BaseProperty");
+class FileProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._value = undefined;
+    }
+}
+exports.FileProperty = FileProperty;
+FileProperty.TYPE = 'file';

package/lib/properties/ObjectProperty copy.d.ts

@@ -0,0 +1,16 @@
+import { ObjectUri } from '../components/ObjectUri';
+import { BaseProperty, BasePropertyType } from './BaseProperty';
+import { BaseObjectClass } from '../components/types/BaseObjectClass';
+export interface ObjectPropertyType extends BasePropertyType {
+    instanceOf: any;
+}
+export declare class ObjectProperty extends BaseProperty {
+    static TYPE: string;
+    _value: BaseObjectClass | ObjectUri | undefined;
+    _instanceOf: any;
+    constructor(config: ObjectPropertyType);
+    get instanceOf(): any;
+    val(transform?: string | undefined): any;
+    set(value: object, setChanged?: boolean): this;
+    toJSON(): any;
+}

package/lib/properties/ObjectProperty copy.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectProperty = void 0;
+const DataObject_1 = require("../components/DataObject");
+const ObjectUri_1 = require("../components/ObjectUri");
+const BaseProperty_1 = require("./BaseProperty");
+const Query_1 = require("../backends/Query");
+const Core_1 = require("../Core");
+class ObjectProperty extends BaseProperty_1.BaseProperty {
+    constructor(config) {
+        super(config);
+        this._value = undefined;
+        this._instanceOf = config.instanceOf;
+    }
+    get instanceOf() {
+        return this._instanceOf;
+    }
+    val(transform = undefined) {
+        if (typeof this._instanceOf === 'string') {
+            this._instanceOf = Core_1.Core.getClass(this._instanceOf);
+        }
+        if (!this._value) {
+            return this._defaultValue;
+        }
+        switch (transform) {
+            case Query_1.returnAs.AS_DATAOBJECTS:
+                if (this._value instanceof DataObject_1.DataObject) {
+                    console.log(`Returning already existing dataObject`);
+                    return this._value;
+                }
+                else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                    console.log(`Converting objectUri -> dataObject`);
+                    return DataObject_1.DataObject.factory({
+                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                        uri: this._value,
+                    });
+                }
+                else {
+                    console.log(`Converting instance -> dataObject`);
+                    return this._value.dataObject;
+                }
+            case Query_1.returnAs.AS_INSTANCES:
+                if (this._value instanceof DataObject_1.DataObject) {
+                    console.log(`Converting dataObject -> instance`);
+                    return Reflect.construct(this._instanceOf, [this._value]);
+                }
+                else if (this._value instanceof ObjectUri_1.ObjectUri) {
+                    // console.log('ObjectProperty', this)
+                    console.log(`Converting objectUri -> dataObject -> instance`);
+                    // console.log(this._instanceOf)
+                    const dao = DataObject_1.DataObject.factory({
+                        properties: Reflect.get(this._instanceOf, 'PROPS_DEFINITION'),
+                        uri: this._value,
+                    });
+                    return Reflect.construct(this._instanceOf, [dao]);
+                }
+                else {
+                    console.log(`Returning already existing instance`);
+                    return this._value;
+                }
+            case Query_1.returnAs.AS_OBJECTURIS:
+            default:
+                return this._value;
+        }
+    }
+    set(value, setChanged = true) {
+        if (value instanceof ObjectUri_1.ObjectUri &&
+            value instanceof DataObject_1.DataObject &&
+            value.constructor.name !== this._instanceOf.constructor.name) {
+            throw new Error(`value ${JSON.stringify(value)} is not an instance of ${this._instanceOf.constructor.name}`);
+        }
+        return super.set(value, setChanged);
+    }
+    toJSON() {
+        if (this._value instanceof ObjectUri_1.ObjectUri) {
+            return this._value.toJSON();
+        }
+        return this._value &&
+            (this._value.dataObject || this._value instanceof DataObject_1.DataObject)
+            ? this._value.dataObject.toReference()
+            : null;
+    }
+}
+exports.ObjectProperty = ObjectProperty;
+ObjectProperty.TYPE = 'object';

package/lib/properties/ObjectProperty.d.ts

@@ -9,6 +9,7 @@ export declare class ObjectProperty extends BaseProperty {
     _value: BaseObjectClass | ObjectUri | undefined;
     _instanceOf: any;
     constructor(config: ObjectPropertyType);
+    get instanceOf(): any;
     val(transform?: string | undefined): any;
     set(value: object, setChanged?: boolean): this;
     toJSON(): any;

package/lib/properties/ObjectProperty.js

@@ -12,11 +12,12 @@ class ObjectProperty extends BaseProperty_1.BaseProperty {
         this._value = undefined;
         this._instanceOf = config.instanceOf;
     }
+    get instanceOf() {
+        return this._instanceOf;
+    }
     val(transform = undefined) {
         if (typeof this._instanceOf === 'string') {
-            //console.log(`Getting instance from string ${this._instanceOf}`)
             this._instanceOf = Core_1.Core.getClass(this._instanceOf);
-            //throw new Error(`Parameter 'instanceOf' was not properly setted`)
         }
         if (!this._value) {
             return this._defaultValue;

package/lib/properties/Property.d.ts

@@ -7,6 +7,7 @@ import { HashPropertyType } from './HashProperty';
 import { StringPropertyType } from './StringProperty';
 import { NumberPropertyType } from './NumberProperty';
 import { ObjectPropertyType } from './ObjectProperty';
+import { FilePropertyType } from './FileProperty';
 export declare class Property {
     static TYPE_ANY: string;
     static TYPE_NUMBER: string;
@@ -18,5 +19,6 @@ export declare class Property {
     static TYPE_DATETIME: string;
     static TYPE_ARRAY: string;
     static TYPE_MAP: string;
-    static factory(params: ObjectPropertyType & StringPropertyType & NumberPropertyType & EnumPropertyType & BooleanPropertyType & HashPropertyType & DateTimePropertyType, parent: DataObjectClass<any>): BaseProperty;
+    static TYPE_FILE: string;
+    static factory(params: ObjectPropertyType & StringPropertyType & NumberPropertyType & EnumPropertyType & BooleanPropertyType & HashPropertyType & DateTimePropertyType & FilePropertyType, parent: DataObjectClass<any>): BaseProperty;
 }

package/lib/properties/Property.js

@@ -12,6 +12,7 @@ const ObjectProperty_1 = require("./ObjectProperty");
 const CollectionProperty_1 = require("./CollectionProperty");
 const ArrayProperty_1 = require("./ArrayProperty");
 const MapProperty_1 = require("./MapProperty");
+const FileProperty_1 = require("./FileProperty");
 class Property {
     static factory(params, parent) {
         params.parent = parent;
@@ -41,6 +42,8 @@ class Property {
                 return new ArrayProperty_1.ArrayProperty(params);
             case MapProperty_1.MapProperty.TYPE:
                 return new MapProperty_1.MapProperty(params);
+            case FileProperty_1.FileProperty.TYPE:
+                return new FileProperty_1.FileProperty(params);
             default:
                 throw new Error(`Unknown property type ${params.type}`);
         }
@@ -57,3 +60,4 @@ Property.TYPE_HASH = 'hash';
 Property.TYPE_DATETIME = 'datetime';
 Property.TYPE_ARRAY = 'array';
 Property.TYPE_MAP = 'map';
+Property.TYPE_FILE = 'file';

package/lib/properties/index.d.ts

@@ -9,9 +9,10 @@ import { BooleanProperty, BooleanPropertyType } from './BooleanProperty';
 import { DateTimeProperty, DateTimePropertyType } from './DateTimeProperty';
 import { ObjectProperty, ObjectPropertyType } from './ObjectProperty';
 import { MapProperty, MapPropertyType } from './MapProperty';
+import { FileProperty, FilePropertyType } from './FileProperty';
 import { CollectionProperty, CollectionPropertyType } from './CollectionProperty';
 import { PropertyTypes } from './types/PropertyTypes';
-export { Property, BaseProperty, BasePropertyType, ArrayProperty, ArrayPropertyType, NumberProperty, NumberPropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, HashProperty, HashPropertyType, MapProperty, MapPropertyType, CollectionProperty, CollectionPropertyType, };
+export { Property, BaseProperty, BasePropertyType, ArrayProperty, ArrayPropertyType, NumberProperty, NumberPropertyType, BooleanProperty, BooleanPropertyType, DateTimeProperty, DateTimePropertyType, EnumProperty, EnumPropertyType, ObjectProperty, ObjectPropertyType, StringProperty, StringPropertyType, HashProperty, HashPropertyType, MapProperty, MapPropertyType, FileProperty, FilePropertyType, CollectionProperty, CollectionPropertyType, };
 type BaseType = {
     type: PropertyTypes;
 };

package/lib/properties/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollectionProperty = exports.MapProperty = exports.HashProperty = exports.StringProperty = exports.ObjectProperty = exports.EnumProperty = exports.DateTimeProperty = exports.BooleanProperty = exports.NumberProperty = exports.ArrayProperty = exports.BaseProperty = exports.Property = void 0;
+exports.CollectionProperty = exports.FileProperty = exports.MapProperty = exports.HashProperty = exports.StringProperty = exports.ObjectProperty = exports.EnumProperty = exports.DateTimeProperty = exports.BooleanProperty = exports.NumberProperty = exports.ArrayProperty = exports.BaseProperty = exports.Property = void 0;
 const Property_1 = require("./Property");
 Object.defineProperty(exports, "Property", { enumerable: true, get: function () { return Property_1.Property; } });
 const BaseProperty_1 = require("./BaseProperty");
@@ -23,5 +23,7 @@ const ObjectProperty_1 = require("./ObjectProperty");
 Object.defineProperty(exports, "ObjectProperty", { enumerable: true, get: function () { return ObjectProperty_1.ObjectProperty; } });
 const MapProperty_1 = require("./MapProperty");
 Object.defineProperty(exports, "MapProperty", { enumerable: true, get: function () { return MapProperty_1.MapProperty; } });
+const FileProperty_1 = require("./FileProperty");
+Object.defineProperty(exports, "FileProperty", { enumerable: true, get: function () { return FileProperty_1.FileProperty; } });
 const CollectionProperty_1 = require("./CollectionProperty");
 Object.defineProperty(exports, "CollectionProperty", { enumerable: true, get: function () { return CollectionProperty_1.CollectionProperty; } });

package/lib/storages/AbstractStorageAdapter.d.ts

@@ -2,10 +2,16 @@
 import { Readable } from 'stream';
 import { FileType } from './types/FileType';
 import { StorageAdapterInterface } from './StorageAdapterInterface';
+import { DownloadFileMeta } from './types/DownloadFileMetaType';
+import { StorageParameters } from '../Storage';
 export declare abstract class AbstractStorageAdapter implements StorageAdapterInterface {
+    protected _alias: string;
+    protected _params: StorageParameters;
+    constructor(params?: StorageParameters);
     abstract getDriver(): any;
     abstract create(file: FileType, stream: Readable): Promise<FileType>;
-    abstract download(file: FileType, path: string): Promise<string>;
+    abstract download(file: FileType, path: DownloadFileMeta): Promise<any>;
+    abstract copy(file: FileType, destFile: FileType): Promise<any>;
     abstract getUrl(file: FileType, expiresIn?: number, action?: string, extra?: any): Promise<any>;
     abstract delete(file: FileType): Promise<Boolean>;
     abstract stream(file: FileType, res: any): Promise<any>;

package/lib/storages/AbstractStorageAdapter.js

@@ -3,5 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractStorageAdapter = void 0;
 //import { APIResponseLink, ResponsePublicUrl } from './types'
 class AbstractStorageAdapter {
+    constructor(params = {}) {
+        this._alias = '';
+        this._params = {};
+        this._alias = params.alias || '';
+        this._params = params;
+    }
 }
 exports.AbstractStorageAdapter = AbstractStorageAdapter;

package/lib/storages/StorageAdapterInterface.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
-import { Readable } from "stream";
-import { FileType } from "./types/FileType";
+import { Readable } from 'stream';
+import { FileType } from './types/FileType';
+import { DownloadFileMeta } from './types/DownloadFileMetaType';
 /**
  * These are the public functions that any storage interface must expose
  */
@@ -9,7 +10,7 @@ export interface StorageAdapterInterface {
     create(file: FileType, stream: Readable): Promise<FileType>;
     delete(file: FileType): Promise<Boolean>;
     stream(file: FileType, res: any): Promise<any>;
-    download(file: FileType, path: string): Promise<string>;
+    download(file: FileType, path: DownloadFileMeta): Promise<string>;
     getUrl(file: FileType, expiresIn?: number, action?: string, extra?: any): Promise<any>;
     getUploadUrl(filePath: FileType, expiresIn?: number): Promise<any>;
     getReadable(filePath: FileType): Promise<Readable>;

package/lib/storages/index.d.ts

@@ -3,6 +3,7 @@ import { BlobType } from './types/BlobType';
 import { BlobMediaType } from './types/BlobMediaType';
 import { FileResponseLink } from './types/FileResponseLink';
 import { FileResponseUrl } from './types/FileResponseUrl';
+import { DownloadFileMeta } from './types/DownloadFileMetaType';
 import { StorageAdapterInterface } from './StorageAdapterInterface';
 import { AbstractStorageAdapter } from './AbstractStorageAdapter';
-export { FileType, BlobType, BlobMediaType, FileResponseLink, FileResponseUrl, StorageAdapterInterface, AbstractStorageAdapter, };
+export { FileType, BlobType, BlobMediaType, FileResponseLink, FileResponseUrl, DownloadFileMeta, StorageAdapterInterface, AbstractStorageAdapter, };

package/lib/storages/types/DownloadFileMetaType.d.ts

@@ -0,0 +1,4 @@
+export interface DownloadFileMeta {
+    path: string;
+    onlyContent?: boolean;
+}

package/lib/storages/types/DownloadFileMetaType.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@quatrain/core",
-   "version": "1.0.0-beta22",
+   "version": "1.0.0-beta23",
    "description": "Core objects for business apps",
    "main": "lib/index.js",
    "types": "lib/index.d.ts",