@nomalism-com/api 0.33.83 → 0.34.2

package/src/modules/user/segmentsArea.ts

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

package/src/modules/user/sessions.ts

@@ -0,0 +1,25 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICreateRequest = Nomalism.Sessions.ICreateRequest;
+export import ICreateResponse = Nomalism.Sessions.ICreateResponse;
+
+export default class Repository implements Nomalism.Sessions.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<ICreateResponse> {
+    const response = await this.api.post(`${this.publicRoute}`, body);
+    return response.data;
+  }
+}

package/src/modules/user/shippings.ts

@@ -0,0 +1,71 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.Shippings.IFindRequest;
+export import IFindResponse = Nomalism.Shippings.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.Shippings.IFindPaginatedRequest;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+
+export import ICreateRequest = Nomalism.Shippings.ICreateRequest;
+export import IEntity = Nomalism.Shippings.Entity;
+
+export import IUpdateRequest = Nomalism.Shippings.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.Shippings.IFindResponse>;
+
+export default class Repository implements Nomalism.Shippings.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/storeOperator.ts

@@ -0,0 +1,99 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.StoreOperator.IFindRequest;
+export import IFindResponse = Nomalism.StoreOperator.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.StoreOperator.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.StoreOperator.IFindByOwnerIdResponse;
+
+export import IFindByIdResponse = Nomalism.StoreOperator.IFindByIdResponse;
+
+export import ICreateRequest = Nomalism.StoreOperator.ICreateRequest;
+
+export import IEntity = Nomalism.StoreOperator.Entity;
+
+export import IUpdateRequest = Nomalism.StoreOperator.IUpdateRequest;
+
+export import ICheckPinRequest = Nomalism.StoreOperator.ICheckPinRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.StoreOperator.IFindResponse>;
+
+export default class Repository implements Nomalism.StoreOperator.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<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> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async checkPin(data: ICheckPinRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}pin`, data);
+    return response.data;
+  }
+
+  async updateStoreOperator(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.StoreOperator.IStoreOperatorUpdateRequest,
+  ): Promise<void> {
+    await this.api.put(`${this.route}store_operator${selector.id}`, body);
+  }
+}

package/src/modules/user/swift.ts

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

package/src/modules/user/tenant.ts

@@ -0,0 +1,45 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Tenant.Entity;
+
+export import ICreateRequest = Nomalism.Tenant.ICreateRequest;
+export import IUpdateRequest = Nomalism.Tenant.IUpdateRequest;
+
+export default class Repository implements Nomalism.Tenant.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+}

package/src/modules/user/theme.ts

@@ -0,0 +1,25 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Theme.Entity;
+
+export import createOrUpdate = Nomalism.Theme.ICreateOrUpdateRequest;
+
+export default class Repository implements Nomalism.Theme.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async createOrUpdate(body: createOrUpdate): Promise<void> {
+    await this.api.post(`${this.route}`, body);
+  }
+}

package/src/modules/user/user.ts

@@ -0,0 +1,93 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.Users.IFindRequest;
+export import IFindResponse = Nomalism.Users.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.Users.IFindPaginatedRequest;
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import IFindByIdResponse = Nomalism.Users.IFindByIdResponse;
+
+export import IFindProvidersWithClientIdRequest = Nomalism.Users.IFindProvidersWithClientIdRequest;
+export import IFindProvidersWithClientIdResponse = Nomalism.Users.IFindProvidersWithClientIdResponse;
+
+export import ICreateRequest = Nomalism.Users.ICreateRequest;
+
+export import IEntity = Nomalism.Users.Entity;
+
+export import IUpdateRequest = Nomalism.Users.IUpdateRequest;
+export import IFindFromClientOrProviderRequest = Nomalism.Users.IFindFromClientOrProviderRequest;
+export import IFindFromClientOrProviderResponse = Nomalism.Users.IFindFromClientOrProviderResponse;
+export type IPaginationResponse = Nomalism.shared.IPaginationResponse<Nomalism.Users.IFindResponse>;
+
+export default class Repository implements Nomalism.Users.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<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> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findProvidersWithClientId(
+    body: IFindProvidersWithClientIdRequest,
+  ): Promise<IFindProvidersWithClientIdResponse[]> {
+    const response = await this.api.post(`${this.route}providers`, body);
+    return response.data;
+  }
+
+  async findFromClientOrProviderId(
+    body: IFindFromClientOrProviderRequest,
+  ): Promise<IFindFromClientOrProviderResponse[]> {
+    const response = await this.api.post(`${this.route}from_client_or_provider_id`, body);
+    return response.data;
+  }
+}

package/src/modules/user/userPermission.ts

@@ -0,0 +1,43 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.UserPermissions.IFindByOwnerIdResponse;
+
+export import ICreateRequest = Nomalism.UserPermissions.ICreateRequest;
+
+export import IEntity = Nomalism.UserPermissions.Entity;
+
+export default class Repository implements Nomalism.UserPermissions.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindByOwnerIdResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdNumberRequest,
+  ): Promise<IFindByOwnerIdResponse | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/user/userPositions.ts

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

package/src/modules/user/vehicles.ts

@@ -0,0 +1,46 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Vehicles.Entity;
+
+export import ICreateRequest = Nomalism.Vehicles.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.Vehicles.IUpdateRequest;
+
+export default class Repository implements Nomalism.Vehicles.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}