@stemy/backend 5.2.1 → 6.0.0

package/utilities/decorators.d.ts

@@ -1,10 +1,10 @@
-export declare function IsDocumented(summary?: string, paramDescriptions?: {
-    [name: string]: string;
-}): (...args: [Function] | [object, string, PropertyDescriptor]) => void;
-export declare function JsonResponse(description?: string, statusCode?: number): (...args: [Function] | [object, string, PropertyDescriptor]) => void;
-export interface IResponseTypeOptions {
-    description?: string;
-    statusCode?: number;
-    isArray?: boolean;
-}
-export declare function ResponseType(type: Function, options?: IResponseTypeOptions): (...args: [Function] | [object, string, PropertyDescriptor]) => void;
+export declare function IsDocumented(summary?: string, paramDescriptions?: {
+    [name: string]: string;
+}): (...args: [Function] | [object, string, PropertyDescriptor]) => void;
+export declare function JsonResponse(description?: string, statusCode?: number): (...args: [Function] | [object, string, PropertyDescriptor]) => void;
+export interface IResponseTypeOptions {
+    description?: string;
+    statusCode?: number;
+    isArray?: boolean;
+}
+export declare function ResponseType(type: Function, options?: IResponseTypeOptions): (...args: [Function] | [object, string, PropertyDescriptor]) => void;

package/utilities/di-container.d.ts

@@ -1,43 +1,43 @@
-import { ClassProvider, DependencyContainer, Frequency, InjectionToken, RegistrationOptions, TokenProvider, ValueProvider } from "tsyringe";
-import { FactoryProvider, IDependencyContainer, ITree, Type } from "../common-types";
-import { Tree } from "./tree";
-interface PreResolutionInterceptorCallback<T = any> {
-    (token: InjectionToken<T>, resolutionType: "Single" | "All"): void;
-}
-interface PostResolutionInterceptorCallback<T = any> {
-    (token: InjectionToken<T>, result: T | T[], resolutionType: "Single" | "All"): void;
-}
-export declare class DiContainer implements IDependencyContainer {
-    protected container: DependencyContainer;
-    readonly parent: IDependencyContainer;
-    get registeredTokens(): ReadonlyArray<InjectionToken>;
-    get tree(): ITree;
-    protected tokens: Array<InjectionToken>;
-    protected tokenSet: Set<InjectionToken>;
-    protected root: Tree;
-    constructor(container: DependencyContainer, parent?: IDependencyContainer);
-    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: {
-        frequency: Frequency;
-    }): void;
-    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: {
-        frequency: Frequency;
-    }): void;
-    clearInstances(): void;
-    createChildContainer(): IDependencyContainer;
-    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean;
-    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;
-    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;
-    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
-    registerSingleton<T>(token: Type<T>): IDependencyContainer;
-    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
-    reset(): void;
-    resolve<T>(token: InjectionToken<T>): T;
-    resolveAll<T>(token: InjectionToken<T>): T[];
-    get<T>(token: InjectionToken<T>): T;
-    protected addToken<T>(token: InjectionToken<T>): this;
-}
-export {};
+import { ClassProvider, DependencyContainer, Frequency, InjectionToken, RegistrationOptions, TokenProvider, ValueProvider } from "tsyringe";
+import { FactoryProvider, IDependencyContainer, ITree, Type } from "../common-types";
+import { Tree } from "./tree";
+interface PreResolutionInterceptorCallback<T = any> {
+    (token: InjectionToken<T>, resolutionType: "Single" | "All"): void;
+}
+interface PostResolutionInterceptorCallback<T = any> {
+    (token: InjectionToken<T>, result: T | T[], resolutionType: "Single" | "All"): void;
+}
+export declare class DiContainer implements IDependencyContainer {
+    protected container: DependencyContainer;
+    readonly parent: IDependencyContainer;
+    get registeredTokens(): ReadonlyArray<InjectionToken>;
+    get tree(): ITree;
+    protected tokens: Array<InjectionToken>;
+    protected tokenSet: Set<InjectionToken>;
+    protected root: Tree;
+    constructor(container: DependencyContainer, parent?: IDependencyContainer);
+    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: {
+        frequency: Frequency;
+    }): void;
+    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: {
+        frequency: Frequency;
+    }): void;
+    clearInstances(): void;
+    createChildContainer(): IDependencyContainer;
+    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean;
+    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;
+    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;
+    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
+    registerSingleton<T>(token: Type<T>): IDependencyContainer;
+    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
+    reset(): void;
+    resolve<T>(token: InjectionToken<T>): T;
+    resolveAll<T>(token: InjectionToken<T>): T[];
+    get<T>(token: InjectionToken<T>): T;
+    protected addToken<T>(token: InjectionToken<T>): this;
+}
+export {};

package/utilities/empty-job.d.ts

@@ -1,4 +1,4 @@
-import { IJob } from "../common-types";
-export declare class EmptyJob implements IJob {
-    process(): Promise<any>;
-}
+import { IJob } from "../common-types";
+export declare class EmptyJob implements IJob {
+    process(): Promise<any>;
+}

package/utilities/lazy-asset-generator.d.ts

@@ -1,15 +1,15 @@
-import { IAsset, IJob, IMessageBridge, IProgress } from "../common-types";
-import { Assets } from "../services/assets";
-import { LazyAssets } from "../services/lazy-assets";
-import { AssetResolver } from "../services/asset-resolver";
-import { Progresses } from "../services/progresses";
-export declare abstract class LazyAssetGenerator implements IJob {
-    protected assetResolver: AssetResolver;
-    protected progresses: Progresses;
-    protected lazyId: string;
-    get assets(): Assets;
-    get lazyAssets(): LazyAssets;
-    protected constructor(assetResolver: AssetResolver, progresses: Progresses, lazyId: string);
-    abstract generate(progress: IProgress, messaging?: IMessageBridge): Promise<IAsset>;
-    process(messaging: IMessageBridge): Promise<any>;
-}
+import { IAsset, IJob, IMessageBridge, IProgress } from "../common-types";
+import { Assets } from "../services/assets";
+import { LazyAssets } from "../services/lazy-assets";
+import { AssetResolver } from "../services/asset-resolver";
+import { Progresses } from "../services/progresses";
+export declare abstract class LazyAssetGenerator implements IJob {
+    protected assetResolver: AssetResolver;
+    protected progresses: Progresses;
+    protected lazyId: string;
+    get assets(): Assets;
+    get lazyAssets(): LazyAssets;
+    protected constructor(assetResolver: AssetResolver, progresses: Progresses, lazyId: string);
+    abstract generate(progress: IProgress, messaging?: IMessageBridge): Promise<IAsset>;
+    process(messaging: IMessageBridge): Promise<any>;
+}

package/utilities/mongoose.d.ts

@@ -1,36 +1,36 @@
-import { Document, FilterQuery, Model, PipelineStage, Query, Schema } from "mongoose";
-import { DocumentType, ReturnModelType } from "@typegoose/typegoose";
-import { Action } from "routing-controllers";
-import { InjectionToken } from "tsyringe";
-import { IMatchField, InferGeneric, IPaginationBase, IPaginationParams, IProjectOptions, IUnwindOptions, Type } from "../common-types";
-/**
- * A mongoose/typegoose plugin to inject services from the main di container to a schema as virtuals
- * @param schema
- * @param services
- */
-export declare function injectServices(schema: Schema<any>, services?: {
-    [prop: string]: InjectionToken<any>;
-}): void;
-/**
- * Decorates a property to inject a service with the help of the injectServices mongoose/typegoose plugin
- * @param token optional InjectionToken to use
- * @return PropertyDecorator
- */
-export declare function service(token?: InjectionToken<any>): PropertyDecorator;
-/**
- * Paginate using a typegoose model using a simple where query and pagination params
- * @param model Typegoose model
- * @param where Simple query to filter the results
- * @param params Pagination params
- */
-export declare function paginate<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, where: FilterQuery<DocumentType<U>>, params: IPaginationParams): Promise<IPaginationBase<DocumentType<U>>>;
-export declare function lookupStages(from: string, localField: string, as?: string, foreignField?: string, shouldUnwind?: boolean): [PipelineStage.Lookup, PipelineStage.Unwind];
-export declare function letsLookupStage(from: string, pipeline: Exclude<PipelineStage, PipelineStage.Merge | PipelineStage.Out | PipelineStage.Search>[], as?: string, letFields?: any): PipelineStage.Lookup;
-export declare function matchStage(match: FilterQuery<any>): PipelineStage.Match;
-export declare function matchField(field: string, filter: any, when: boolean): IMatchField;
-export declare function matchFieldStages(...fields: IMatchField[]): ReadonlyArray<PipelineStage.Match>;
-export declare function projectStage(fields: IProjectOptions): PipelineStage.Project;
-export declare function unwindStage(fieldOrOpts: string | IUnwindOptions): PipelineStage.Unwind;
-export declare function hydratePopulated<T extends Document>(modelType: Model<T>, json: any): T;
-export declare function paginateAggregations<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, aggregations: PipelineStage[], params: IPaginationParams, metaProjection?: any): Promise<IPaginationBase<DocumentType<U>>>;
-export declare function ResolveEntity<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, extraCheck?: (query: Query<DocumentType<U>, any>, action: Action) => Promise<DocumentType<U>>): ParameterDecorator;
+import { Document, FilterQuery, Model, PipelineStage, Query, Schema } from "mongoose";
+import { DocumentType, ReturnModelType } from "@typegoose/typegoose";
+import { Action } from "routing-controllers";
+import { InjectionToken } from "tsyringe";
+import { IMatchField, InferGeneric, IPaginationBase, IPaginationParams, IProjectOptions, IUnwindOptions, Type } from "../common-types";
+/**
+ * A mongoose/typegoose plugin to inject services from the main di container to a schema as virtuals
+ * @param schema
+ * @param services
+ */
+export declare function injectServices(schema: Schema<any>, services?: {
+    [prop: string]: InjectionToken<any>;
+}): void;
+/**
+ * Decorates a property to inject a service with the help of the injectServices mongoose/typegoose plugin
+ * @param token optional InjectionToken to use
+ * @return PropertyDecorator
+ */
+export declare function service(token?: InjectionToken<any>): PropertyDecorator;
+/**
+ * Paginate using a typegoose model using a simple where query and pagination params
+ * @param model Typegoose model
+ * @param where Simple query to filter the results
+ * @param params Pagination params
+ */
+export declare function paginate<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, where: FilterQuery<DocumentType<U>>, params: IPaginationParams): Promise<IPaginationBase<DocumentType<U>>>;
+export declare function lookupStages(from: string, localField: string, as?: string, foreignField?: string, shouldUnwind?: boolean): [PipelineStage.Lookup, PipelineStage.Unwind];
+export declare function letsLookupStage(from: string, pipeline: Exclude<PipelineStage, PipelineStage.Merge | PipelineStage.Out | PipelineStage.Search>[], as?: string, letFields?: any): PipelineStage.Lookup;
+export declare function matchStage(match: FilterQuery<any>): PipelineStage.Match;
+export declare function matchField(field: string, filter: any, when: boolean): IMatchField;
+export declare function matchFieldStages(...fields: IMatchField[]): ReadonlyArray<PipelineStage.Match>;
+export declare function projectStage(fields: IProjectOptions): PipelineStage.Project;
+export declare function unwindStage(fieldOrOpts: string | IUnwindOptions): PipelineStage.Unwind;
+export declare function hydratePopulated<T extends Document>(modelType: Model<T>, json: any): T;
+export declare function paginateAggregations<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, aggregations: PipelineStage[], params: IPaginationParams, metaProjection?: any): Promise<IPaginationBase<DocumentType<U>>>;
+export declare function ResolveEntity<T extends Type<any>, U = InferGeneric<T>>(model: ReturnModelType<T>, extraCheck?: (query: Query<DocumentType<U>, any>, action: Action) => Promise<DocumentType<U>>): ParameterDecorator;

package/utilities/tree.d.ts

@@ -1,15 +1,15 @@
-import { IDependencyContainer, ITree } from "../common-types";
-export declare class Tree implements ITree {
-    protected container: IDependencyContainer;
-    protected exists: boolean;
-    readonly path: string;
-    protected map: Map<string, Tree>;
-    protected get parentTree(): ITree;
-    constructor(container: IDependencyContainer, exists: boolean, path: string);
-    resolveService(): any;
-    resolveLeaves(): Map<string, ITree>;
-    resolveServices(): Map<string, any>;
-    resolveAncestor(path: string): ITree;
-    resolvePath(path: string, throwError?: boolean): ITree;
-    addPath(path: string): this;
-}
+import { IDependencyContainer, ITree } from "../common-types";
+export declare class Tree implements ITree {
+    protected container: IDependencyContainer;
+    protected exists: boolean;
+    readonly path: string;
+    protected map: Map<string, Tree>;
+    protected get parentTree(): ITree;
+    constructor(container: IDependencyContainer, exists: boolean, path: string);
+    resolveService(): any;
+    resolveLeaves(): Map<string, ITree>;
+    resolveServices(): Map<string, any>;
+    resolveAncestor(path: string): ITree;
+    resolvePath(path: string, throwError?: boolean): ITree;
+    addPath(path: string): this;
+}

package/utils.d.ts

@@ -1,123 +1,120 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ZlibOptions } from "zlib";
-import { DependencyContainer } from "tsyringe";
-import { Observable, Subscription } from "rxjs";
-import { Server } from "socket.io";
-import { GridFSBucket, ObjectId } from "mongodb";
-import { Document } from "mongoose";
-import { Readable, ReadableOptions } from "stream";
-import { IAssetImageParams, IAssetMeta, IClientSocket, IFileType, ParamResolver, Type } from "./common-types";
-export interface IDIContainers {
-    appContainer: DependencyContainer;
-}
-export declare const diContainers: IDIContainers;
-export type FilterPredicate = (value: any, key?: any, target?: any, source?: any) => boolean;
-export declare function isNullOrUndefined(value: any): boolean;
-export declare function isDefined(value: any): boolean;
-export declare function getType(obj: any): string;
-export declare function isObject(value: any): boolean;
-export declare function isArray(value: any): value is Array<any>;
-export declare function isBuffer(value: any): value is Buffer;
-export declare function isBoolean(value: any): value is boolean;
-export declare function isDate(value: any): value is Date;
-export declare function isPrimitive(value: any): boolean;
-export declare function isString(value: any): value is string;
-export declare function isFunction(value: any): value is Function;
-export declare function isConstructor(value: any): boolean;
-export declare function isType(value: any): value is Type<any>;
-export declare function isInterface(obj: any, interFaceObject: {
-    [key: string]: string;
-}): boolean;
-export declare function ucFirst(value: string): string;
-export declare function lcFirst(value: string): string;
-export declare function isObjectId(id: string): boolean;
-export declare function firstItem<T>(value: T[]): T;
-export declare function lastItem<T>(value: T[]): T;
-export declare function regroup<T>(value: T[], comparator: (a: T, b: T) => boolean): Array<T[]>;
-export declare function uniqueItems<T>(value: T[]): T[];
-export declare function getValue(obj: any, key: string, defaultValue?: any, treeFallback?: boolean): any;
-export declare function groupBy<T>(items: T[], cb: (item: T) => string): {};
-export declare function convertValue(value: any, type: string): any;
-export declare function toImage<T = Buffer | Readable>(src: T, params?: IAssetImageParams, meta?: IAssetMeta): Promise<T>;
-export declare function bufferToStream(buffer: Buffer): Readable;
-export declare function streamToBuffer(stream: Readable): Promise<Buffer>;
-export declare function copyStream(stream: Readable, opts?: ReadableOptions): Readable;
-export declare function mkdirRecursive(path: string, mode?: number): Promise<void>;
-export declare function deleteFile(path: string): Promise<void>;
-export declare function readFile(path: string): Promise<Buffer>;
-export declare function readAndDeleteFile(path: string, timeout?: number): Promise<Buffer>;
-export declare function writeFile(path: string, data: Buffer): Promise<Buffer>;
-export declare function valueToPromise(value: any): Promise<any>;
-export declare function promiseTimeout(timeout?: number, error?: boolean): Promise<string>;
-export declare function getConstructorName(type: Type<any>): string;
-export declare function getFunctionParams(func: Function): string[];
-export declare function getFileName(path: string, withExtension?: boolean): string;
-export declare function getExtension(path: string): string;
-export declare function createIdString(): any;
-export declare function idToString(value: any): any;
-export declare function createTransformer(transform?: (doc: Document, ret: any, options?: any) => any): (doc: Document, ret: any, options?: any) => any;
-export declare function broadcast(socketServer: Server, cb: (client: IClientSocket) => void): void;
-export declare function rand(min: number, max: number): number;
-export declare function random(min: number, max: number): number;
-export declare function multiSubscription(...subscriptions: Subscription[]): Subscription;
-export declare function observableFromFunction(callbackFunc: () => any): Observable<any>;
-export declare function padLeft(value: any, count?: number, padWith?: string): string;
-export declare function padRight(value: any, count?: number, padWith?: string): string;
-export declare function camelCaseToDash(str: string): string;
-export declare function gzipPromised(data: string, opts?: ZlibOptions): Promise<string>;
-export declare function gunzipPromised(data: string, opts?: ZlibOptions): Promise<string>;
-export declare function deleteFromBucket(bucket: GridFSBucket, id: ObjectId | string): Promise<string>;
-export declare function filter<T>(obj: T, predicate: FilterPredicate): Partial<T>;
-export declare function copy<T>(obj: T): T;
-export declare function assign<T>(target: T, source: any, predicate?: FilterPredicate): T;
-export declare function md5(data: any): string;
-export declare function runCommand(scriptPath: string, expectedCode?: number): Promise<string>;
-export declare enum ConsoleColor {
-    Reset = "\u001B[0m",
-    Bright = "\u001B[1m",
-    Dim = "\u001B[2m",
-    Underscore = "\u001B[4m",
-    Blink = "\u001B[5m",
-    Reverse = "\u001B[7m",
-    Hidden = "\u001B[8m",
-    FgBlack = "\u001B[30m",
-    FgRed = "\u001B[31m",
-    FgGreen = "\u001B[32m",
-    FgYellow = "\u001B[33m",
-    FgBlue = "\u001B[34m",
-    FgMagenta = "\u001B[35m",
-    FgCyan = "\u001B[36m",
-    FgWhite = "\u001B[37m",
-    FgDefault = "\u001B[38m",
-    BgBlack = "\u001B[40m",
-    BgRed = "\u001B[41m",
-    BgGreen = "\u001B[42m",
-    BgYellow = "\u001B[43m",
-    BgBlue = "\u001B[44m",
-    BgMagenta = "\u001B[45m",
-    BgCyan = "\u001B[46m",
-    BgWhite = "\u001B[47m",
-    BgDefault = "\u001B[48m"
-}
-export interface IJsonColors {
-    keyColor?: ConsoleColor;
-    numberColor?: ConsoleColor;
-    stringColor?: ConsoleColor;
-    trueColor?: ConsoleColor;
-    falseColor?: ConsoleColor;
-    nullColor?: ConsoleColor;
-}
-export declare function colorize(input: any, color: ConsoleColor): string;
-export declare function jsonHighlight(input: string | object, colorOptions?: IJsonColors): string;
-export declare function replaceSpecialChars(str: string, to?: string): string;
-export declare function regexEscape(str: string): string;
-export declare function flatten(arr: any[]): any[];
-export declare function wrapError(e: any, message: string, httpCode?: number): Error;
-export declare function getDirName(): string;
-export declare function prepareUrl(ending?: string): ParamResolver;
-export declare const prepareUrlSlash: ParamResolver;
-export declare const prepareUrlEmpty: ParamResolver;
-export declare function fileTypeFromBuffer(buffer: Buffer): Promise<IFileType>;
-export declare function fileTypeFromStream(buffer: Buffer): Promise<IFileType>;
+import { ZlibOptions } from "zlib";
+import { Observable, Subscription } from "rxjs";
+import { Server } from "socket.io";
+import { GridFSBucket, ObjectId } from "mongodb";
+import { Document } from "mongoose";
+import { Readable, ReadableOptions } from "stream";
+import { AnyWebByteStream } from "strtok3";
+import { IAssetImageParams, IAssetMeta, IClientSocket, IDependencyContainer, IFileType, ParamResolver, Type } from "./common-types";
+export interface IDIContainers {
+    appContainer: IDependencyContainer;
+}
+export declare const diContainers: IDIContainers;
+export type FilterPredicate = (value: any, key?: any, target?: any, source?: any) => boolean;
+export declare function isNullOrUndefined(value: any): boolean;
+export declare function isDefined(value: any): boolean;
+export declare function getType(obj: any): string;
+export declare function isObject(value: any): boolean;
+export declare function isArray(value: any): value is Array<any>;
+export declare function isBuffer(value: any): value is Buffer;
+export declare function isBoolean(value: any): value is boolean;
+export declare function isDate(value: any): value is Date;
+export declare function isPrimitive(value: any): boolean;
+export declare function isString(value: any): value is string;
+export declare function isFunction(value: any): value is Function;
+export declare function isConstructor(value: any): boolean;
+export declare function isType(value: any): value is Type<any>;
+export declare function isInterface(obj: any, interFaceObject: {
+    [key: string]: string;
+}): boolean;
+export declare function ucFirst(value: string): string;
+export declare function lcFirst(value: string): string;
+export declare function isObjectId(id: string): boolean;
+export declare function firstItem<T>(value: T[]): T;
+export declare function lastItem<T>(value: T[]): T;
+export declare function regroup<T>(value: T[], comparator: (a: T, b: T) => boolean): Array<T[]>;
+export declare function uniqueItems<T>(value: T[]): T[];
+export declare function getValue(obj: any, key: string, defaultValue?: any, treeFallback?: boolean): any;
+export declare function groupBy<T>(items: T[], cb: (item: T) => string): {};
+export declare function convertValue(value: any, type: string): any;
+export declare function toImage<T = Buffer | Readable>(src: T, params?: IAssetImageParams, meta?: IAssetMeta): Promise<T>;
+export declare function bufferToStream(buffer: Buffer): Readable;
+export declare function streamToBuffer(stream: Readable): Promise<Buffer>;
+export declare function copyStream(stream: Readable, opts?: ReadableOptions): Readable;
+export declare function mkdirRecursive(path: string, mode?: number): Promise<void>;
+export declare function deleteFile(path: string): Promise<void>;
+export declare function readFile(path: string): Promise<Buffer>;
+export declare function readAndDeleteFile(path: string, timeout?: number): Promise<Buffer>;
+export declare function writeFile(path: string, data: Buffer): Promise<Buffer>;
+export declare function valueToPromise(value: any): Promise<any>;
+export declare function promiseTimeout(timeout?: number, error?: boolean): Promise<string>;
+export declare function getConstructorName(type: Type<any>): string;
+export declare function getFunctionParams(func: Function): string[];
+export declare function getFileName(path: string, withExtension?: boolean): string;
+export declare function getExtension(path: string): string;
+export declare function createIdString(): any;
+export declare function idToString(value: any): any;
+export declare function createTransformer(transform?: (doc: Document, ret: any, options?: any) => any): (doc: Document, ret: any, options?: any) => any;
+export declare function broadcast(socketServer: Server, cb: (client: IClientSocket) => void): void;
+export declare function rand(min: number, max: number): number;
+export declare function random(min: number, max: number): number;
+export declare function multiSubscription(...subscriptions: Subscription[]): Subscription;
+export declare function observableFromFunction(callbackFunc: () => any): Observable<any>;
+export declare function padLeft(value: any, count?: number, padWith?: string): string;
+export declare function padRight(value: any, count?: number, padWith?: string): string;
+export declare function camelCaseToDash(str: string): string;
+export declare function gzipPromised(data: string, opts?: ZlibOptions): Promise<string>;
+export declare function gunzipPromised(data: string, opts?: ZlibOptions): Promise<string>;
+export declare function deleteFromBucket(bucket: GridFSBucket, id: ObjectId | string): Promise<string>;
+export declare function filter<T>(obj: T, predicate: FilterPredicate): Partial<T>;
+export declare function copy<T>(obj: T): T;
+export declare function assign<T>(target: T, source: any, predicate?: FilterPredicate): T;
+export declare function md5(data: any): string;
+export declare function runCommand(scriptPath: string, expectedCode?: number): Promise<string>;
+export declare enum ConsoleColor {
+    Reset = "\u001B[0m",
+    Bright = "\u001B[1m",
+    Dim = "\u001B[2m",
+    Underscore = "\u001B[4m",
+    Blink = "\u001B[5m",
+    Reverse = "\u001B[7m",
+    Hidden = "\u001B[8m",
+    FgBlack = "\u001B[30m",
+    FgRed = "\u001B[31m",
+    FgGreen = "\u001B[32m",
+    FgYellow = "\u001B[33m",
+    FgBlue = "\u001B[34m",
+    FgMagenta = "\u001B[35m",
+    FgCyan = "\u001B[36m",
+    FgWhite = "\u001B[37m",
+    FgDefault = "\u001B[38m",
+    BgBlack = "\u001B[40m",
+    BgRed = "\u001B[41m",
+    BgGreen = "\u001B[42m",
+    BgYellow = "\u001B[43m",
+    BgBlue = "\u001B[44m",
+    BgMagenta = "\u001B[45m",
+    BgCyan = "\u001B[46m",
+    BgWhite = "\u001B[47m",
+    BgDefault = "\u001B[48m"
+}
+export interface IJsonColors {
+    keyColor?: ConsoleColor;
+    numberColor?: ConsoleColor;
+    stringColor?: ConsoleColor;
+    trueColor?: ConsoleColor;
+    falseColor?: ConsoleColor;
+    nullColor?: ConsoleColor;
+}
+export declare function colorize(input: any, color: ConsoleColor): string;
+export declare function jsonHighlight(input: string | object, colorOptions?: IJsonColors): string;
+export declare function replaceSpecialChars(str: string, to?: string): string;
+export declare function regexEscape(str: string): string;
+export declare function flatten(arr: any[]): any[];
+export declare function wrapError(e: any, message: string, httpCode?: number): Error;
+export declare function getDirName(): string;
+export declare function prepareUrl(ending?: string): ParamResolver;
+export declare const prepareUrlSlash: ParamResolver;
+export declare const prepareUrlEmpty: ParamResolver;
+export declare function fileTypeFromBuffer(buffer: Buffer): Promise<IFileType>;
+export declare function fileTypeFromStream(stream: AnyWebByteStream): Promise<IFileType>;

package/validators.d.ts

@@ -1,7 +1,7 @@
-import { ValidationArguments, ValidatorConstraintInterface } from "class-validator";
-export declare class IsFile implements ValidatorConstraintInterface {
-    validate(value: any, validationArguments: ValidationArguments): boolean;
-}
-export declare class IsObjectId implements ValidatorConstraintInterface {
-    validate(value: any, validationArguments: ValidationArguments): boolean;
-}
+import { ValidationArguments, ValidatorConstraintInterface } from "class-validator";
+export declare class IsFile implements ValidatorConstraintInterface {
+    validate(value: any, validationArguments: ValidationArguments): boolean;
+}
+export declare class IsObjectId implements ValidatorConstraintInterface {
+    validate(value: any, validationArguments: ValidationArguments): boolean;
+}