taon 0.0.0 → 18.0.12

package/browser/index.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="taon" />
+export * from './public-api';

package/browser/lib/base-classes/base-abstract-entity.d.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { BaseEntity } from './base-entity';
+import type { BaseClass } from './base-class';
+export declare abstract class BaseAbstractEntity<CloneT extends BaseClass = any> extends BaseEntity<CloneT> {
+    id: string;
+    version: number;
+}

package/browser/lib/base-classes/base-class.d.ts

@@ -0,0 +1,9 @@
+// @ts-nocheck
+export declare class BaseClass<CloneT extends BaseClass = any> {
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    _(): Promise<void>;
+    clone(override: Partial<CloneT>): CloneT;
+}

package/browser/lib/base-classes/base-context.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+declare const BaseContext: {
+    types: {
+        readonly controllers: Record<string, new (...args: any[]) => any>;
+        readonly repositories: Record<string, new (...args: any[]) => any>;
+        readonly providers: Record<string, new (...args: any[]) => any>;
+        readonly subscribers: Record<string, new (...args: any[]) => any>;
+    };
+    readonly contexts: Record<string, object>;
+    readonly contextName: string;
+    __ref(): Promise<import("../endpoint-context").EndpointContext>;
+    readonly __refSync: import("../endpoint-context").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: () => Promise<import("../endpoint-context").EndpointContext>;
+};
+export { BaseContext };

package/browser/lib/base-classes/base-controller.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { BaseInjector } from './base-injector';
+export declare class BaseController extends BaseInjector {
+    /**
+     * init example data for db
+     */
+    initExampleDbData(): Promise<any>;
+}

package/browser/lib/base-classes/base-crud-controller.d.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { BaseController } from './base-controller';
+import { BaseRepository } from './base-repository';
+import { Models } from '../models';
+/**
+ * Please override property entityClassFn with entity class.
+ */
+export declare abstract class BaseCrudController<Entity> extends BaseController {
+    protected db?: BaseRepository<Entity>;
+    /**
+     * Please provide entity as class propery entityClassFn:
+     * @returns class function
+     *
+     */
+    abstract entityClassResolveFn: () => any;
+    _(): Promise<void>;
+    bufforedChanges(id: number | string, property: string, alreadyLength?: number): Models.Http.Response<string | any[]>;
+    pagination(pageNumber?: number, pageSize?: number, search?: string): Models.Http.Response<Entity[]>;
+    getAll(): Models.Http.Response<Entity[]>;
+    getBy(id: number | string): Models.Http.Response<Entity>;
+    updateById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    patchById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    bulkUpdate(items: Entity[]): Models.Http.Response<Entity[]>;
+    deleteById(id: number): Models.Http.Response<Entity>;
+    bulkDelete(ids: (number | string)[]): Models.Http.Response<(number | string | Entity)[]>;
+    create(item: Entity): Models.Http.Response<Entity>;
+    bulkCreate(items: Entity): Models.Http.Response<Entity[]>;
+}

package/browser/lib/base-classes/base-entity.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { BaseClass } from './base-class';
+export declare abstract class BaseEntity<
+/**
+ * type for cloning
+ */
+CloneT extends BaseClass = any> extends BaseClass<CloneT> {
+}

package/browser/lib/base-classes/base-injector.d.ts

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import { EndpointContext } from '../endpoint-context';
+import type { BaseRepository } from './base-repository';
+import { BaseClass } from './base-class';
+export declare class BaseInjector<CloneT extends BaseClass = any> {
+    /**
+     * for proxy purposes
+     */
+    getOriginalPrototype: () => any;
+    /**
+     * for proxy purposes
+     */
+    getOriginalConstructor: () => any;
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    _(): Promise<void>;
+    /**
+     * Current endpoint context
+     */
+    get __endpoint_context__(): EndpointContext;
+    /**
+     * inject crud repo for entity
+     */
+    injectRepo<T>(entityForCrud: new (...args: any[]) => T): BaseRepository<T>;
+    injectCustomRepository<T>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    /**
+     * aliast to .injectRepository()
+     */
+    injectCustomRepo<T>(cutomRepositoryClass: new (...args: any[]) => T): T;
+    injectController<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * aliast to .injectController()
+     */
+    injectSubscriber<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * aliast to .injectController()
+     */
+    injectCtrl<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * global provider available in every context
+     */
+    injectGlobalProvider<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * context scoped provider
+     * TODO
+     */
+    injectContextProvider<T>(ctor: new (...args: any[]) => T): T;
+    /**
+     * Repositories to init (by controller)
+     */
+    protected __repositories_to_init__: BaseRepository<any>[];
+    /**
+     * Inject: Controllers, Providers, Repositories, Services, etc.
+     * TODO  addd nest js injecting
+     */
+    private __inject;
+    clone(override: Partial<CloneT>): CloneT;
+}

package/browser/lib/base-classes/base-provider.d.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+import { BaseInjector } from './base-injector';
+export declare class BaseProvider extends BaseInjector {
+}

package/browser/lib/base-classes/base-repository.d.ts

@@ -0,0 +1,249 @@
+// @ts-nocheck
+import type { FindManyOptions, FindOneOptions, FindOptionsWhere, InsertResult, SaveOptions, UpdateResult } from 'taon-typeorm';
+import type { QueryDeepPartialEntity } from 'taon-typeorm/lib/typeorm/query-builder/QueryPartialEntity';
+import type { UpsertOptions } from 'taon-typeorm/lib/typeorm/repository/UpsertOptions';
+import type { DataSource as DataSourceType } from 'taon-typeorm/browser';
+import { MySqlQuerySource } from 'taon-type-sql/browser';
+import { BaseInjector } from './base-injector';
+export declare abstract class BaseRepository<Entity extends {
+    id?: any;
+}> extends BaseInjector {
+    private __entityClassResolveFn;
+    abstract entityClassResolveFn: () => any;
+    constructor(__entityClassResolveFn: () => any);
+    private __dbQuery;
+    get dbQuery(): MySqlQuerySource;
+    get connection(): DataSourceType;
+    protected get repository(): any;
+    /**
+     * target for repository
+     */
+    get target(): Function;
+    /**
+     * alias to repository
+     */
+    protected get repo(): any;
+    get repositoryExists(): boolean;
+    __init(context?: any): Promise<void>;
+    /**
+     * Checks if entity has an id.
+     * If entity composite compose ids, it will check them all.
+     */
+    hasId(entity: Entity): boolean;
+    /**
+     * Gets entity mixed id.
+     */
+    getId(entity: Entity): any;
+    /**
+      Saves a given entity in the database.
+     * If entity does not exist in the database then inserts, otherwise updates.
+     */
+    save(item: Entity, options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity>;
+    /**
+     * alias to save
+     * -> it will actuall create new entity in db
+     * in oposite to typeorm create method
+     */
+    create(item: Entity, options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity>;
+    bulkSave(items: Entity[], options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity[]>;
+    bulkCreate(items: Entity[], options?: SaveOptions & {
+        reload: false;
+    }): Promise<Entity[]>;
+    /**
+     * Saves all given entities in the database.
+     * If entities do not exist in the database then inserts, otherwise updates.
+     */
+    /**
+     * Merges multiple entities (or entity-like objects) into a given entity.
+     */
+    merge(mergeIntoEntity: Entity, ...entityLikes: Entity[]): Entity;
+    /**
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
+     * it loads it (and everything related to it), replaces all values with the new ones from the given object
+     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
+     * replaced from the new object.
+     *
+     * Note that given entity-like object must have an entity id / primary key to find entity by.
+     * Returns undefined if entity with given id was not found.
+     */
+    preload(entityLike: Entity): Promise<Entity | undefined>;
+    /**
+     * Removes a given entities from the database.
+     */
+    remove(idOrEntity: number | string | Entity): Promise<Entity>;
+    /**
+     * alias to remove
+     */
+    delete(idOrEntity: number | string | Entity): Promise<Entity>;
+    /**
+     * alias to removeById
+     */
+    deleteById(id: number | string): Promise<Entity>;
+    bulkRemove(idsOrEntities: (number | string | Entity)[]): Promise<Entity[]>;
+    bulkDelete(ids: (number | string | Entity)[]): Promise<Entity[]>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends Entity>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends Entity>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove<T extends Entity>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends Entity>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends Entity>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover<T extends Entity>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Inserts a given entity into the database.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT query.
+     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
+     */
+    insert(entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
+    update(item: Entity): Promise<any>;
+    updateById(id: number | string, item: Entity): Promise<any>;
+    bulkUpdate(items: Entity[]): Promise<any>;
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria: string | string[] | number | number[] | Date | Date[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria: string | string[] | number | number[] | Date | Date[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
+    /**
+     * Counts entities that match given options.
+     * Useful for pagination.
+     */
+    count(options?: FindManyOptions<Entity>): Promise<number>;
+    /**
+     * Counts entities that match given conditions.
+     * Useful for pagination.
+     */
+    countBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number>;
+    /**
+     * Finds entities that match given find options.
+     */
+    find(options?: FindManyOptions<Entity>): Promise<Entity[]>;
+    /**
+     * Finds entities that match given find options.
+     */
+    findBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity[]>;
+    /**
+     * Finds entities that match given find options.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCount(options?: FindManyOptions<Entity>): Promise<[Entity[], number]>;
+    /**
+     * Finds entities that match given WHERE conditions.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCountBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<[Entity[], number]>;
+    /**
+     * Finds entities with ids.
+     * Optionally find options or conditions can be applied.
+     *
+     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findBy({
+     *     id: In([1, 2, 3])
+     * })
+     */
+    findByIds(ids: any[]): Promise<Entity[]>;
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
+     */
+    findOne(options: FindOneOptions<Entity>): Promise<Entity | null>;
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
+     */
+    findOneBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity | null>;
+    /**
+     * Finds first entity that matches given id.
+     * If entity was not found in the database - returns null.
+     *
+     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
+     *
+     * .findOneBy({
+     *     id: 1 // where "id" is your primary column name
+     * })
+     */
+    findOneById(id: number | string | Date): Promise<Entity | null>;
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneOrFail(options: FindOneOptions<Entity>): Promise<Entity>;
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
+     */
+    findOneByOrFail(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity>;
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    query(query: string, parameters?: any[]): Promise<any>;
+    /**
+     * Clears all the data from the given table/collection (truncates/drops it).
+     *
+     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @see https://stackoverflow.com/a/5972738/925151
+     */
+    clear(): Promise<void>;
+    /**
+     * Increments some column by provided value of the entities matched given conditions.
+     */
+    increment(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    /**
+     * Decrements some column by provided value of the entities matched given conditions.
+     */
+    decrement(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    /**
+     * @deprecated use findAndCount instead
+     */
+    getAll(): Promise<any>;
+    getBy(id: number | string): Promise<Entity>;
+}

package/browser/lib/base-classes/base-subscriber-for-entity.d.ts

@@ -0,0 +1,82 @@
+// @ts-nocheck
+import { EntitySubscriberInterface, RecoverEvent, SoftRemoveEvent, InsertEvent, TransactionStartEvent, TransactionCommitEvent, TransactionRollbackEvent, RemoveEvent, UpdateEvent } from 'taon-typeorm/browser';
+import { BaseInjector } from './base-injector';
+export declare abstract class BaseSubscriberForEntity<Entity = any> extends BaseInjector implements EntitySubscriberInterface {
+    abstract listenTo(): new (...args: any[]) => Entity;
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity: any): void;
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event: any): void;
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event: any): void;
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event: InsertEvent<any>): void;
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event: InsertEvent<any>): void;
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event: UpdateEvent<any>): void;
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event: UpdateEvent<any>): void;
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event: RemoveEvent<any>): void;
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event: RemoveEvent<any>): void;
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event: SoftRemoveEvent<any>): void;
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event: SoftRemoveEvent<any>): void;
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event: RecoverEvent<any>): void;
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event: RecoverEvent<any>): void;
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event: TransactionStartEvent): void;
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event: TransactionStartEvent): void;
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event: TransactionCommitEvent): void;
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event: TransactionCommitEvent): void;
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event: TransactionRollbackEvent): void;
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event: TransactionRollbackEvent): void;
+}

package/browser/lib/base-classes/base-subscriber.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { BaseInjector } from './base-injector';
+export declare abstract class BaseSubscriber<Entity = any> extends BaseInjector {
+    protected __trigger_event__(eventName: keyof Entity): void;
+}

package/browser/lib/base-classes/base.d.ts

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import * as controller from './base-controller';
+import * as crudController from './base-crud-controller';
+import * as entity from './base-entity';
+import * as abstractEntity from './base-abstract-entity';
+import * as repository from './base-repository';
+import * as provider from './base-provider';
+import * as baseclass from './base-class';
+import * as baseSubscriber from './base-subscriber';
+import * as baseSubscriberEntity from './base-subscriber-for-entity';
+export declare namespace Base {
+    export import Controller = controller.BaseController;
+    export import CrudController = crudController.BaseCrudController;
+    export import Entity = entity.BaseEntity;
+    export import AbstractEntity = abstractEntity.BaseAbstractEntity;
+    export import Provider = provider.BaseProvider;
+    export import Class = baseclass.BaseClass;
+    export import Repository = repository.BaseRepository;
+    export import Subscriber = baseSubscriber.BaseSubscriber;
+    export import SubscriberForEntity = baseSubscriberEntity.BaseSubscriberForEntity;
+    const Context: {
+        types: {
+            readonly controllers: Record<string, new (...args: any[]) => any>;
+            readonly repositories: Record<string, new (...args: any[]) => any>;
+            readonly providers: Record<string, new (...args: any[]) => any>;
+            readonly subscribers: Record<string, new (...args: any[]) => any>;
+        };
+        readonly contexts: Record<string, object>;
+        readonly contextName: string;
+        __ref(): Promise<import("../endpoint-context").EndpointContext>;
+        readonly __refSync: import("../endpoint-context").EndpointContext;
+        getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+        getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+        initialize: () => Promise<import("../endpoint-context").EndpointContext>;
+    };
+}

package/browser/lib/constants.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export type TaonEntityKeysToOmit = 'ctrl' | 'clone' | '__endpoint_context__' | 'inject' | '_';

package/browser/lib/create-context.d.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import { EndpointContext } from './endpoint-context';
+import { Models } from './models';
+export declare const createContext: <CTX extends Record<string, object>, CTRL extends Record<string, new (...args: any[]) => any>, ENTITY extends Record<string, new (...args: any[]) => any>, REPO extends Record<string, new (...args: any[]) => any>, PROVIDER extends Record<string, new (...args: any[]) => any>, SUBSCRIBER extends Record<string, new (...args: any[]) => any>>(configFn: (env: any) => Models.ContextOptions<CTX, CTRL, ENTITY, REPO, PROVIDER, SUBSCRIBER>) => {
+    types: {
+        readonly controllers: CTRL;
+        readonly repositories: REPO;
+        readonly providers: PROVIDER;
+        readonly subscribers: SUBSCRIBER;
+    };
+    readonly contexts: CTX;
+    readonly contextName: string;
+    /**
+     * - get reference to internal context
+     */
+    __ref(): Promise<EndpointContext>;
+    readonly __refSync: EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    /**
+     * - create controller instances for context
+     * - init database (if enable) + migation scripts
+     */
+    initialize: () => Promise<EndpointContext>;
+};

package/browser/lib/decorators/classes/controller-decorator.d.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import { Models } from '../../models';
+export declare function TaonController(options?: TaonControllerOptions): (constructor: Function) => void;
+export declare class TaonControllerOptions extends Models.DecoratorAbstractOpt {
+    /**
+     * typeorm realtime subscribtion // TODO disabled for now, does not make sense ?s
+     */
+    realtime?: boolean;
+    /**
+     * override default path for controller api
+     */
+    path?: string;
+}

package/browser/lib/decorators/classes/entity-decorator.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { Mapping } from 'ng2-rest/browser';
+import { Models } from '../../models';
+export declare function TaonEntity<T = any>(options?: TaonEntityOptions<T>): (constructor: Function) => void;
+export declare class TaonEntityOptions<T = any> extends Models.DecoratorAbstractOpt {
+    /**
+     * default unique property is "id"
+     * for your entity it may be something else
+     */
+    uniqueKeyProp?: string;
+    createTable?: boolean;
+    defaultModelValues?: Mapping.ModelValue<T>;
+    defaultModelMapping?: Mapping.Mapping<T>;
+    defaultModelMappingDeep?: {
+        [lodashPathes: string]: string | [string];
+    };
+}

package/browser/lib/decorators/classes/provider-decorator.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { Models } from '../../models';
+export declare function TaonProvider<T = any>(options?: TaonProviderOptions<T>): (constructor: Function) => void;
+export declare class TaonProviderOptions<T = any> extends Models.DecoratorAbstractOpt {
+}

package/browser/lib/decorators/classes/repository-decorator.d.ts

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { Models } from '../../models';
+export declare function TaonRepository(options: TaonRepositoryOptions): (constructor: Function) => void;
+export declare class TaonRepositoryOptions<T = any> extends Models.DecoratorAbstractOpt {
+}

package/browser/lib/decorators/classes/subscriber-decorator.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { Models } from '../../models';
+export declare class TaonSubscriberOptions<T = any> extends Models.DecoratorAbstractOpt {
+    allowedEvents?: (keyof T)[];
+}
+export declare function TaonSubscriber(options: TaonSubscriberOptions): any;

package/browser/lib/decorators/http/http-decorators.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import * as methods from './http-methods-decorators';
+import * as params from './http-params-decorators';
+export declare namespace Http {
+    export import GET = methods.GET;
+    export import POST = methods.POST;
+    export import PUT = methods.PUT;
+    export import DELETE = methods.DELETE;
+    export import PATCH = methods.PATCH;
+    export import HEAD = methods.HEAD;
+    namespace Param {
+        export import Query = params.Query;
+        export import Path = params.Path;
+        export import Body = params.Body;
+        export import Cookie = params.Cookie;
+        export import Header = params.Header;
+    }
+}

package/browser/lib/decorators/http/http-methods-decorators.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/browser';
+import { Models as ModelsNg2Rest } from 'ng2-rest/browser';
+export interface TaonHttpDecoratorOptions {
+    path?: string;
+    pathIsGlobal?: boolean;
+    overrideContentType?: CoreModels.ContentType;
+    overridResponseType?: ModelsNg2Rest.ResponseTypeAxios;
+}
+export declare function GET(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function HEAD(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function POST(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function PUT(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function PATCH(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function DELETE(pathOrOptions?: string | TaonHttpDecoratorOptions, pathIsGlobal?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/browser/lib/decorators/http/http-params-decorators.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+export declare function Path(name: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Query(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Cookie(name: string, expireInSecond?: number): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Header(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare function Body(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;