@nomalism-com/api 0.34.2 → 0.34.3

package/src/modules/user/commissioner.ts

@@ -2,24 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindRequest = Nomalism.Commissioner.IFindRequest;
-export import IFindResponse = Nomalism.Commissioner.IFindResponse;
-
-export import IFindPaginatedRequest = Nomalism.Commissioner.IFindPaginatedRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
-export import IFindByOwnerIdResponse = Nomalism.Commissioner.IFindByOwnerIdResponse;
-
-export import IFindByIdResponse = Nomalism.Commissioner.IFindByIdResponse;
-
-export import ICreateRequest = Nomalism.Commissioner.ICreateRequest;
-
-export import IEntity = Nomalism.Commissioner.Entity;
-
-export import IUpdateRequest = Nomalism.Commissioner.IUpdateRequest;
 export type IPaginationResponse =
   Nomalism.shared.IPaginationResponse<Nomalism.Commissioner.IFindResponse>;
 
@@ -36,49 +18,63 @@ export default class Repository implements Nomalism.Commissioner.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(params: IFindRequest): Promise<IFindResponse[]> {
+  async find(
+    params: Nomalism.Commissioner.IFindRequest,
+  ): Promise<Nomalism.Commissioner.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+  async findPaginated(
+    params: Nomalism.Commissioner.IFindPaginatedRequest,
+  ): Promise<IPaginationResponse> {
     const response = await this.api.get(`${this.route}paginated`, { params });
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+  async findByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.Commissioner.IFindByOwnerIdResponse[]> {
     const response = await this.api.get(`${this.route}by_owner`, {
       params,
     });
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Commissioner.IFindByIdResponse | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IFindResponse> {
+  async create(
+    body: Nomalism.Commissioner.ICreateRequest,
+  ): Promise<Nomalism.Commissioner.IFindResponse> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IFindResponse | null> {
+    body: Nomalism.Commissioner.IUpdateRequest,
+  ): Promise<Nomalism.Commissioner.IFindResponse | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Commissioner.IFindResponse | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/country.ts

@@ -2,18 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindRequest = Nomalism.Country.IFindRequest;
-export import IFindResponse = Nomalism.Country.IFindResponse;
-
-export import IFindPaginatedRequest = Nomalism.Country.IFindPaginatedRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import ICreateRequest = Nomalism.Country.ICreateRequest;
-export import IEntity = Nomalism.Country.Entity;
-
-export import IUpdateRequest = Nomalism.Country.IUpdateRequest;
 export type IPaginationResponse =
   Nomalism.shared.IPaginationResponse<Nomalism.Country.IFindResponse>;
 
@@ -30,49 +18,59 @@ export default class Repository implements Nomalism.Country.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(params: IFindRequest): Promise<IFindResponse[]> {
+  async find(params: Nomalism.Country.IFindRequest): Promise<Nomalism.Country.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+  async findPaginated(
+    params: Nomalism.Country.IFindPaginatedRequest,
+  ): Promise<IPaginationResponse> {
     const response = await this.api.get(`${this.route}paginated`, { params });
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async findByAlpha2(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findByAlpha2(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}alpha2`, {
       params,
     });
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Country.IFindResponse | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(body: Nomalism.Country.ICreateRequest): Promise<Nomalism.Country.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.Country.IUpdateRequest,
+  ): Promise<Nomalism.Country.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Country.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/deliveryMethods.ts

@@ -2,15 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.DeliveryMethods.Entity;
-
-export import ICreateRequest = Nomalism.DeliveryMethods.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.DeliveryMethods.IUpdateRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
 export default class Repository implements Nomalism.DeliveryMethods.IRepository {
   public route: string;
 
@@ -24,37 +15,45 @@ export default class Repository implements Nomalism.DeliveryMethods.IRepository
     this.publicRoute = publicRoute;
   }
 
-  async find(): Promise<IEntity[]> {
+  async find(): Promise<Nomalism.DeliveryMethods.Entity[]> {
     const response = await this.api.get(`${this.route}`);
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.DeliveryMethods.Entity | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(
+    body: Nomalism.DeliveryMethods.ICreateRequest,
+  ): Promise<Nomalism.DeliveryMethods.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.DeliveryMethods.IUpdateRequest,
+  ): Promise<Nomalism.DeliveryMethods.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.DeliveryMethods.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/favorites.ts

@@ -2,13 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindOneRequest = Nomalism.Favorites.IFindOneRequest;
-
-export import ICreateRequest = Nomalism.Favorites.ICreateRequest;
-export import IDeleteRequest = Nomalism.Favorites.IDeleteRequest;
-
-export import IEntity = Nomalism.Favorites.Entity;
-
 export default class Repository implements Nomalism.Favorites.IRepository {
   public route: string;
 
@@ -22,22 +15,24 @@ export default class Repository implements Nomalism.Favorites.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async findByUrl(params: IFindOneRequest): Promise<boolean> {
+  async findByUrl(params: Nomalism.Favorites.IFindOneRequest): Promise<boolean> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async list(): Promise<IEntity[]> {
+  async list(): Promise<Nomalism.Favorites.Entity[]> {
     const response = await this.api.get(`${this.route}list`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(body: Nomalism.Favorites.ICreateRequest): Promise<Nomalism.Favorites.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
-  async deleteOne(params: IDeleteRequest): Promise<IEntity | null> {
+  async deleteOne(
+    params: Nomalism.Favorites.IDeleteRequest,
+  ): Promise<Nomalism.Favorites.Entity | null> {
     const response = await this.api.delete(`${this.route}`, { params });
     return response.data;
   }

package/src/modules/user/groupPermission.ts

@@ -2,12 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import ICreateRequest = Nomalism.GroupPermissions.ICreateRequest;
-export import IEntity = Nomalism.GroupPermissions.Entity;
-
 export default class Repository implements Nomalism.GroupPermissions.IApi {
   public route: string;
 
@@ -26,19 +20,25 @@ export default class Repository implements Nomalism.GroupPermissions.IApi {
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(
+    body: Nomalism.GroupPermissions.ICreateRequest,
+  ): Promise<Nomalism.GroupPermissions.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdNumberRequest,
+  ): Promise<Nomalism.GroupPermissions.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/language.ts

@@ -2,18 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindRequest = Nomalism.Language.IFindRequest;
-export import IFindResponse = Nomalism.Language.IFindResponse;
-
-export import IFindPaginatedRequest = Nomalism.Language.IFindPaginatedRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import ICreateRequest = Nomalism.Language.ICreateRequest;
-export import IEntity = Nomalism.Language.Entity;
-
-export import IUpdateRequest = Nomalism.Language.IUpdateRequest;
 export type IPaginationResponse =
   Nomalism.shared.IPaginationResponse<Nomalism.Language.IFindResponse>;
 
@@ -30,42 +18,50 @@ export default class Repository implements Nomalism.Language.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(params: IFindRequest): Promise<IFindResponse[]> {
+  async find(params: Nomalism.Language.IFindRequest): Promise<Nomalism.Language.IFindResponse[]> {
     const response = await this.api.get(`${this.route}`, { params });
     return response.data;
   }
 
-  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+  async findPaginated(
+    params: Nomalism.Language.IFindPaginatedRequest,
+  ): Promise<IPaginationResponse> {
     const response = await this.api.get(`${this.route}paginated`, { params });
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Language.IFindResponse | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(body: Nomalism.Language.ICreateRequest): Promise<Nomalism.Language.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.Language.IUpdateRequest,
+  ): Promise<Nomalism.Language.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Language.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/maturityDates.ts

@@ -2,15 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.MaturityDates.Entity;
-
-export import ICreateRequest = Nomalism.MaturityDates.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.MaturityDates.IUpdateRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
 export default class Repository implements Nomalism.MaturityDates.IRepository {
   public route: string;
 
@@ -24,37 +15,45 @@ export default class Repository implements Nomalism.MaturityDates.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(): Promise<IEntity[]> {
+  async find(): Promise<Nomalism.MaturityDates.Entity[]> {
     const response = await this.api.get(`${this.route}`);
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.MaturityDates.Entity | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(
+    body: Nomalism.MaturityDates.ICreateRequest,
+  ): Promise<Nomalism.MaturityDates.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.MaturityDates.IUpdateRequest,
+  ): Promise<Nomalism.MaturityDates.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.MaturityDates.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/password.ts

@@ -2,10 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IForgotPassword = Nomalism.Password.IForgotPassword;
-
-export import IResetPassword = Nomalism.Password.IResetPassword;
-
 export default class Repository implements Nomalism.Password.IRepository {
   public route: string;
 
@@ -19,11 +15,11 @@ export default class Repository implements Nomalism.Password.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async forgotPassword(body: IForgotPassword): Promise<void> {
+  async forgotPassword(body: Nomalism.Password.IForgotPassword): Promise<void> {
     await this.api.post(`${this.publicRoute}forgot`, body);
   }
 
-  async resetPassword(body: IResetPassword): Promise<void> {
+  async resetPassword(body: Nomalism.Password.IResetPassword): Promise<void> {
     await this.api.post(`${this.publicRoute}reset`, body);
   }
 }

package/src/modules/user/paymentMethods.ts

@@ -2,15 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IEntity = Nomalism.PaymentMethods.Entity;
-
-export import ICreateRequest = Nomalism.PaymentMethods.ICreateRequest;
-
-export import IUpdateRequest = Nomalism.PaymentMethods.IUpdateRequest;
-
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
 export default class Repository implements Nomalism.PaymentMethods.IRepository {
   public route: string;
 
@@ -24,37 +15,45 @@ export default class Repository implements Nomalism.PaymentMethods.IRepository {
     this.publicRoute = publicRoute;
   }
 
-  async find(): Promise<IEntity[]> {
+  async find(): Promise<Nomalism.PaymentMethods.Entity[]> {
     const response = await this.api.get(`${this.route}`);
     return response.data;
   }
 
-  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async findById(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.PaymentMethods.Entity | null> {
     const response = await this.api.get(`${this.route}${selector.id}`);
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(
+    body: Nomalism.PaymentMethods.ICreateRequest,
+  ): Promise<Nomalism.PaymentMethods.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
   async update(
     selector: Nomalism.shared.IFindByIdRequest,
-    body: IUpdateRequest,
-  ): Promise<IEntity | null> {
+    body: Nomalism.PaymentMethods.IUpdateRequest,
+  ): Promise<Nomalism.PaymentMethods.Entity | null> {
     const response = await this.api.put(`${this.route}${selector.id}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.PaymentMethods.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }

package/src/modules/user/permission.ts

@@ -2,12 +2,6 @@ import Nomalism from '@nomalism-com/types';
 import { AxiosInstance } from 'axios';
 import { IModuleConstructor } from '../../main';
 
-export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
-export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
-
-export import ICreateRequest = Nomalism.Permissions.ICreateRequest;
-export import IEntity = Nomalism.Permissions.Entity;
-
 export default class Repository implements Nomalism.Permissions.IApi {
   public route: string;
 
@@ -26,19 +20,23 @@ export default class Repository implements Nomalism.Permissions.IApi {
     return response.data;
   }
 
-  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+  async findMinified(
+    params?: Nomalism.shared.IFindMinifiedRequest,
+  ): Promise<Nomalism.shared.IFindMinifiedResponse[]> {
     const response = await this.api.get(`${this.route}minified`, {
       params,
     });
     return response.data;
   }
 
-  async create(body: ICreateRequest): Promise<IEntity> {
+  async create(body: Nomalism.Permissions.ICreateRequest): Promise<Nomalism.Permissions.Entity> {
     const response = await this.api.post(`${this.route}`, body);
     return response.data;
   }
 
-  async deleteOne(selector: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdNumberRequest,
+  ): Promise<Nomalism.Permissions.Entity | null> {
     const response = await this.api.delete(`${this.route}${selector.id}`);
     return response.data;
   }