@spytecgps/nova-orm 1.2.29-rc8 → 1.2.29

package/dist/repositories/boundaries/getBoundariesIdsByClientId.js

@@ -1,24 +1,24 @@
-import { Boundary } from '../../entities';
-export const getBoundariesIdsByClientId = async (novaDataSource, params, logger) => {
-    if (!params.filters.clientId) {
-        logger.warn({ params }, 'BoundariesRepository::getBoundariesIdsByClientId - missing required parameters');
-        return [];
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const boundariesRepository = dataSource.getRepository(Boundary);
-        const filterCondition = params.filters.status
-            ? { clientId: params.filters.clientId, status: params.filters.status }
-            : { clientId: params.filters.clientId };
-        const queryBuilder = boundariesRepository
-            .createQueryBuilder('boundary')
-            .where(filterCondition);
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const boundariesIds = await queryBuilder.select('id').getRawMany();
-        return boundariesIds.map(x => x.id);
-    }, 'BoundariesRepository::getBoundariesIdsByClientId', dbQueryRunner);
-};
+import { Boundary } from '../../entities';
+export const getBoundariesIdsByClientId = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesIdsByClientId - missing required parameters');
+        return [];
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const filterCondition = params.filters.status
+            ? { clientId: params.filters.clientId, status: params.filters.status }
+            : { clientId: params.filters.clientId };
+        const queryBuilder = boundariesRepository
+            .createQueryBuilder('boundary')
+            .where(filterCondition);
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const boundariesIds = await queryBuilder.select('id').getRawMany();
+        return boundariesIds.map(x => x.id);
+    }, 'BoundariesRepository::getBoundariesIdsByClientId', dbQueryRunner);
+};
 //# sourceMappingURL=getBoundariesIdsByClientId.js.map

package/dist/repositories/boundaries/getBoundariesReport.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BoundariesReportEntity, GetBoundariesReportParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const getBoundariesReport: (novaDataSource: NovaDataSource, params: GetBoundariesReportParams, logger: Logger) => Promise<BoundariesReportEntity[]>;
+import { NovaDataSource } from '../../novaDataSource';
+import { BoundariesReportEntity, GetBoundariesReportParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const getBoundariesReport: (novaDataSource: NovaDataSource, params: GetBoundariesReportParams, logger: Logger) => Promise<BoundariesReportEntity[]>;

package/dist/repositories/boundaries/getBoundariesReport.js

@@ -1,147 +1,147 @@
-import { Enums } from '../..';
-import { Boundary, BoundaryEvent, Device } from '../../entities';
-import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
-export const getBoundariesReport = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.userId) {
-        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - missing required parameters');
-        return [];
-    }
-    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
-    if (!userIdBinaryBuffer?.length) {
-        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - user id should be a valid UUID');
-        return null;
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const boundariesRepository = dataSource.getRepository(BoundaryEvent);
-        const queryBuilder = boundariesRepository
-            .createQueryBuilder('boundaryEvent')
-            .innerJoin(Device, 'device', 'device.id = boundaryEvent.deviceId')
-            .innerJoin(Boundary, 'boundary', 'boundary.id = boundaryEvent.boundaryId')
-            .where('boundaryEvent.userId = :userId', { userId: userIdBinaryBuffer })
-            .andWhere('device.status = :deviceStatus', { deviceStatus: Enums.DeviceStatus.Active });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        if (params.filters.boundaryId) {
-            queryBuilder.andWhere('boundaryEvent.boundaryId = :boundaryId', {
-                boundaryId: params.filters.boundaryId,
-            });
-        }
-        if (params.filters.boundaryName) {
-            queryBuilder.andWhere('boundary.name LIKE :boundaryName', {
-                boundaryName: `%${params.filters.boundaryName}%`,
-            });
-        }
-        if (params.filters.imeis?.length) {
-            queryBuilder.andWhere('device.imei IN (:...imeis)', { imeis: params.filters.imeis });
-        }
-        if (params.filters.boundaryInStartDate) {
-            queryBuilder.andWhere('boundaryEvent.inDate >= :boundaryInStartDate', {
-                boundaryInStartDate: params.filters.boundaryInStartDate,
-            });
-        }
-        if (params.filters.boundaryInEndDate) {
-            queryBuilder.andWhere('boundaryEvent.inDate <= :boundaryInEndDate', {
-                boundaryInEndDate: params.filters.boundaryInEndDate,
-            });
-        }
-        if (params.filters.boundaryOutStartDate) {
-            queryBuilder.andWhere('boundaryEvent.outDate >= :boundaryOutStartDate', {
-                boundaryOutStartDate: params.filters.boundaryOutStartDate,
-            });
-        }
-        if (params.filters.boundaryOutEndDate) {
-            queryBuilder.andWhere('boundaryEvent.outDate <= :boundaryOutEndDate', {
-                boundaryOutEndDate: params.filters.boundaryOutEndDate,
-            });
-        }
-        if (params.filters.minDuration) {
+import { Enums } from '../..';
+import { Boundary, BoundaryEvent, Device } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getBoundariesReport = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundariesReport - user id should be a valid UUID');
+        return null;
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const boundariesRepository = dataSource.getRepository(BoundaryEvent);
+        const queryBuilder = boundariesRepository
+            .createQueryBuilder('boundaryEvent')
+            .innerJoin(Device, 'device', 'device.id = boundaryEvent.deviceId')
+            .innerJoin(Boundary, 'boundary', 'boundary.id = boundaryEvent.boundaryId')
+            .where('boundaryEvent.userId = :userId', { userId: userIdBinaryBuffer })
+            .andWhere('device.status = :deviceStatus', { deviceStatus: Enums.DeviceStatus.Active });
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        if (params.filters.boundaryId) {
+            queryBuilder.andWhere('boundaryEvent.boundaryId = :boundaryId', {
+                boundaryId: params.filters.boundaryId,
+            });
+        }
+        if (params.filters.boundaryName) {
+            queryBuilder.andWhere('boundary.name LIKE :boundaryName', {
+                boundaryName: `%${params.filters.boundaryName}%`,
+            });
+        }
+        if (params.filters.imeis?.length) {
+            queryBuilder.andWhere('device.imei IN (:...imeis)', { imeis: params.filters.imeis });
+        }
+        if (params.filters.boundaryInStartDate) {
+            queryBuilder.andWhere('boundaryEvent.inDate >= :boundaryInStartDate', {
+                boundaryInStartDate: params.filters.boundaryInStartDate,
+            });
+        }
+        if (params.filters.boundaryInEndDate) {
+            queryBuilder.andWhere('boundaryEvent.inDate <= :boundaryInEndDate', {
+                boundaryInEndDate: params.filters.boundaryInEndDate,
+            });
+        }
+        if (params.filters.boundaryOutStartDate) {
+            queryBuilder.andWhere('boundaryEvent.outDate >= :boundaryOutStartDate', {
+                boundaryOutStartDate: params.filters.boundaryOutStartDate,
+            });
+        }
+        if (params.filters.boundaryOutEndDate) {
+            queryBuilder.andWhere('boundaryEvent.outDate <= :boundaryOutEndDate', {
+                boundaryOutEndDate: params.filters.boundaryOutEndDate,
+            });
+        }
+        if (params.filters.minDuration) {
             queryBuilder.andWhere(`((boundaryEvent.inOutDuration IS NOT NULL AND boundaryEvent.inOutDuration >= :minDuration) OR 
          (boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL AND 
             UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate) >= :minDuration
-         ))`, {
-                minDuration: params.filters.minDuration,
-            });
-        }
-        if (params.filters.maxDuration) {
+         ))`, {
+                minDuration: params.filters.minDuration,
+            });
+        }
+        if (params.filters.maxDuration) {
             queryBuilder.andWhere(`((boundaryEvent.inOutDuration IS NOT NULL AND boundaryEvent.inOutDuration <= :maxDuration) OR 
          (boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL AND 
             UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate) <= :maxDuration
-         ))`, {
-                maxDuration: params.filters.maxDuration,
-            });
-        }
-        const subQuery = queryBuilder.clone().select('COUNT(boundaryEvent.id)', 'totalCount');
-        queryBuilder.innerJoin(`(${subQuery.getQuery()})`, 'sub');
-        if (params.sortOptions?.sortField) {
-            let sortField = null;
-            switch (params.sortOptions.sortField) {
-                case 'inDateTime':
-                    sortField = 'boundaryEvent.inDate';
-                    break;
-                case 'outDateTime':
-                    sortField = 'boundaryEvent.outDate';
-                    break;
-                case 'inOutDuration':
+         ))`, {
+                maxDuration: params.filters.maxDuration,
+            });
+        }
+        const subQuery = queryBuilder.clone().select('COUNT(boundaryEvent.id)', 'totalCount');
+        queryBuilder.innerJoin(`(${subQuery.getQuery()})`, 'sub');
+        if (params.sortOptions?.sortField) {
+            let sortField = null;
+            switch (params.sortOptions.sortField) {
+                case 'inDateTime':
+                    sortField = 'boundaryEvent.inDate';
+                    break;
+                case 'outDateTime':
+                    sortField = 'boundaryEvent.outDate';
+                    break;
+                case 'inOutDuration':
                     sortField = `CASE WHEN boundaryEvent.inOutDuration IS NOT NULL 
                           THEN boundaryEvent.inOutDuration 
                        WHEN boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL 
                           THEN UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, "+00:00")) - UNIX_TIMESTAMP(boundaryEvent.inDate) 
                        ELSE NULL
-                       END`;
-                    break;
-                case 'name':
-                    sortField = 'boundary.name';
-                    break;
-            }
-            queryBuilder.orderBy(sortField || 'boundaryEvent.inDate', params.sortOptions.sortOrder || 'DESC');
-        }
-        const result = await queryBuilder
-            .select([
-            'device.id AS deviceId',
-            'device.imei AS imei',
-            'device.name AS deviceName',
-            'boundary.id AS boundaryId',
-            'boundary.name AS boundaryName',
-            'boundaryEvent.inDate AS inDate',
-            'boundaryEvent.inLat AS inLat',
-            'boundaryEvent.inLon AS inLon',
-            'boundaryEvent.inAddress AS inAddress',
-            'boundaryEvent.outDate AS outDate',
-            'boundaryEvent.outLat AS outLat',
-            'boundaryEvent.outLon AS outLon',
-            'boundaryEvent.outAddress AS outAddress',
+                       END`;
+                    break;
+                case 'name':
+                    sortField = 'boundary.name';
+                    break;
+            }
+            queryBuilder.orderBy(sortField || 'boundaryEvent.inDate', params.sortOptions.sortOrder || 'DESC');
+        }
+        const result = await queryBuilder
+            .select([
+            'device.id AS deviceId',
+            'device.imei AS imei',
+            'device.name AS deviceName',
+            'boundary.id AS boundaryId',
+            'boundary.name AS boundaryName',
+            'boundaryEvent.inDate AS inDate',
+            'boundaryEvent.inLat AS inLat',
+            'boundaryEvent.inLon AS inLon',
+            'boundaryEvent.inAddress AS inAddress',
+            'boundaryEvent.outDate AS outDate',
+            'boundaryEvent.outLat AS outLat',
+            'boundaryEvent.outLon AS outLon',
+            'boundaryEvent.outAddress AS outAddress',
             `CASE 
             WHEN boundaryEvent.inOutDuration IS NOT NULL
                 THEN boundaryEvent.inOutDuration
             WHEN boundaryEvent.inOutDuration IS NULL AND boundaryEvent.inDate IS NOT NULL AND boundaryEvent.outDate IS NULL 
                 THEN UNIX_TIMESTAMP(CONVERT_TZ(NOW(), @@session.time_zone, '+00:00')) - UNIX_TIMESTAMP(boundaryEvent.inDate)
             ELSE NULL
-         END AS duration`,
-            `sub.totalCount AS totalCount`,
-        ])
-            .limit(params.pagingOptions.pageSize)
-            .offset(params.pagingOptions.pageSize * params.pagingOptions.pageIndex)
-            .getRawMany();
-        return result.map(row => ({
-            deviceId: row.deviceId,
-            imei: row.imei,
-            deviceName: row.deviceName,
-            boundaryId: row.boundaryId,
-            boundaryName: row.boundaryName,
-            inDate: row.inDate,
-            inLat: row.inLat,
-            inLon: row.inLon,
-            inAddress: row.inAddress,
-            outDate: row.outDate,
-            outLat: row.outLat,
-            outLon: row.outLon,
-            outAddress: row.outAddress,
-            inOutDuration: row.duration,
-            totalCount: row.totalCount,
-        }));
-    }, 'BoundariesRepository::getBoundariesReport', dbQueryRunner);
-};
+         END AS duration`,
+            `sub.totalCount AS totalCount`,
+        ])
+            .limit(params.pagingOptions.pageSize)
+            .offset(params.pagingOptions.pageSize * params.pagingOptions.pageIndex)
+            .getRawMany();
+        return result.map(row => ({
+            deviceId: row.deviceId,
+            imei: row.imei,
+            deviceName: row.deviceName,
+            boundaryId: row.boundaryId,
+            boundaryName: row.boundaryName,
+            inDate: row.inDate,
+            inLat: row.inLat,
+            inLon: row.inLon,
+            inAddress: row.inAddress,
+            outDate: row.outDate,
+            outLat: row.outLat,
+            outLon: row.outLon,
+            outAddress: row.outAddress,
+            inOutDuration: row.duration,
+            totalCount: row.totalCount,
+        }));
+    }, 'BoundariesRepository::getBoundariesReport', dbQueryRunner);
+};
 //# sourceMappingURL=getBoundariesReport.js.map

package/dist/repositories/boundaries/getBoundaryById.d.ts

@@ -1,5 +1,5 @@
-import { Boundary } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { GetBoundaryByIdParams } from '../../types/boundaries';
-import { Logger } from '../../types/logger';
-export declare const getBoundaryById: (novaDataSource: NovaDataSource, params: GetBoundaryByIdParams, logger: Logger) => Promise<Boundary>;
+import { Boundary } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { GetBoundaryByIdParams } from '../../types/boundaries';
+import { Logger } from '../../types/logger';
+export declare const getBoundaryById: (novaDataSource: NovaDataSource, params: GetBoundaryByIdParams, logger: Logger) => Promise<Boundary>;

package/dist/repositories/boundaries/getBoundaryById.js

@@ -1,23 +1,23 @@
-import { Boundary } from '../../entities';
-export const getBoundaryById = async (novaDataSource, params, logger) => {
-    if (!params.filters.boundaryId) {
-        logger.warn({ params }, 'BoundariesRepository::getBoundaryById - missing required parameters');
-        return null;
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const boundariesRepository = dataSource.getRepository(Boundary);
-        const queryBuilder = boundariesRepository
-            .createQueryBuilder('boundary')
-            .where('boundary.id = :boundaryId', { boundaryId: params.filters.boundaryId });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        const boundary = await queryBuilder
-            .where('id = :id', { id: params.filters.boundaryId })
-            .getOne();
-        return boundary;
-    }, 'BoundariesRepository::getBoundaryById', dbQueryRunner);
-};
+import { Boundary } from '../../entities';
+export const getBoundaryById = async (novaDataSource, params, logger) => {
+    if (!params.filters.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::getBoundaryById - missing required parameters');
+        return null;
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const queryBuilder = boundariesRepository
+            .createQueryBuilder('boundary')
+            .where('boundary.id = :boundaryId', { boundaryId: params.filters.boundaryId });
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        const boundary = await queryBuilder
+            .where('id = :id', { id: params.filters.boundaryId })
+            .getOne();
+        return boundary;
+    }, 'BoundariesRepository::getBoundaryById', dbQueryRunner);
+};
 //# sourceMappingURL=getBoundaryById.js.map

package/dist/repositories/boundaries/index.d.ts

@@ -1,106 +1,106 @@
-import { Boundary } from '../../entities';
-import { BoundariesReportEntity, CreateBoundaryParams, DeleteBoundaryParams, GetBoundariesByClientIdParams, GetBoundariesReportParams, GetBoundaryByIdParams, ProcessBoundaryEventParams, UpdateBoundaryParams, UpsertBoundaryEventParams } from '../../types/boundaries';
-import { BaseRepository } from '../baseRepository';
-export declare class BoundariesRepository extends BaseRepository {
-    /**
-     * Get all boundaries by client id
-     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries by clientId
-     * - filters.clientId: The client id
-     * - filters.status: The status to only obtain boundaries with that status, optional
-     */
-    getBoundariesByClientId(params: GetBoundariesByClientIdParams): Promise<Boundary[]>;
-    /**
-     * Get all boundaries ids by client id
-     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries ids by clientId
-     * - filters.clientId: The client id
-     * - filters.status: The status to only obtain boundaries with that status, optional
-     */
-    getBoundariesIdsByClientId(params: GetBoundariesByClientIdParams): Promise<number[]>;
-    /**
-     * Get a boundary by id
-     * @param  {GetBoundaryByIdParams} params containing information to get a boundary by id
-     * - filters.boundaryId: The boundary id
-     */
-    getBoundaryById(params: GetBoundaryByIdParams): Promise<Boundary>;
-    /**
-     * Create a boundary
-     * @param  {CreateBoundaryParams} params containing information to create a boundary
-     * - name: boundary name
-     * - type: boundary type
-     * - clientId: id of the client that owns the boundary
-     * - createdBy: id of the user that created the boundary
-     * - location: location of the boundary
-     * - buffer: buffer of the boundary
-     * - radiusDisplayUnit: radius display unit of the boundary
-     * - color: color of the boundary
-     * - geometry: geometry of the boundary
-     * - status: status of the boundary
-     * - dataSourceTypeId: data source type id of the boundary, optional
-     * - isUserCreated: if the boundary was created by a user, optional
-     * - area: area of the boundary, optional
-     */
-    createBoundary(params: CreateBoundaryParams): Promise<Boundary>;
-    /**
-     * Update a boundary
-     * @param  {UpdateBoundaryParams} params containing information to update a boundary
-     * - filters.boundaryId: The id of the boundary to update
-     * - values.name: The name of the boundary. Optional, if undefined, the name will not be updated.
-     * - values.type: The type of the boundary. Optional, if undefined, the type will not be updated.
-     * - values.modifiedBy: The user id of the user that modified the boundary. Optional, if undefined, the modifiedBy will not be updated.
-     * - values.location: The location of the boundary. Optional, if undefined, the location will not be updated.
-     * - values.geometry: The geometry of the boundary. Optional, if undefined, the geometry will not be updated.
-     * - values.status: The status of the boundary. Optional, if undefined, the status will not be updated.
-     * - values.buffer: The buffer of the boundary. Optional, if undefined, the buffer will not be updated.
-     * - values.radiusDisplayUnit: The radius display unit of the boundary. Optional, if undefined, the radius display unit will not be updated.
-     * - values.color: The color of the boundary. Optional, if undefined, the color will not be updated.
-     * - values.area: The area of the boundary. Optional, if undefined, the area will not be updated.
-     */
-    updateBoundary(params: UpdateBoundaryParams): Promise<boolean>;
-    /**
-     * Delete a boundary
-     * @param  {DeleteBoundaryParams} params containing information to delete a boundary
-     * The boundary will not be removed from the database, it will only be marked as deleted
-     * - filters.boundaryId: The id of the boundary to delete
-     * - values.modifiedBy: The user id of the user that deleted the boundary
-     */
-    deleteBoundary(params: DeleteBoundaryParams): Promise<boolean>;
-    /**
-     * Get boundaries report
-     * @param  {GetBoundariesReportParams} params containing information to get boundaries report
-     * - filters.userId: The user id
-     * - filters.boundaryId: The boundary id, optional
-     * - filters.boundaryName: The boundary name, optional
-     * - filters.imeis: The imeis, optional
-     * - filters.boundaryInStartDate: The boundary in start date, optional
-     * - filters.boundaryInEndDate: The boundary in end date, optional
-     * - filters.boundaryOutStartDate: The boundary out start date, optional
-     * - filters.boundaryOutEndDate: The boundary out end date, optional
-     * - pagingOptions.pageSize: The page size of the pagination, required
-     * - pagingOptions.pageIndex: The page index of the pagination, required
-     * - sortOptions.sortField: The field to sort the pagination, optional
-     * - sortOptions.sortOrder: The order to sort the pagination, optional
-     * @returns The boundaries report
-     */
-    getBoundariesReport(params: GetBoundariesReportParams): Promise<BoundariesReportEntity[]>;
-    /**
-     * Process boundary event
-     * @param  {ProcessBoundaryEventParams} params containing information to process boundary event
-     * - boundaryId: The boundary id
-     * - imei: The imei of the device
-     * - userId: The user id
-     * - sendTime: The event date
-     * - eventType: The event type (enter or exit)
-     * - lat: The latitude of the event
-     * - lon: The longitude of the event
-     * - address: The address of the event
-     * @returns true if the event was processed, false otherwise
-     */
-    processBoundaryEvent(params: ProcessBoundaryEventParams): Promise<boolean>;
-    /**
-     * Upsert boundary event
-     * @param  {UpsertBoundaryEventParams} params containing information to upsert boundary event
-     * - id: The id of the boundary event
-     * @returns true if the event was upserted, false otherwise
-     */
-    upsertBoundaryEvent(params: UpsertBoundaryEventParams): Promise<boolean>;
-}
+import { Boundary } from '../../entities';
+import { BoundariesReportEntity, CreateBoundaryParams, DeleteBoundaryParams, GetBoundariesByClientIdParams, GetBoundariesReportParams, GetBoundaryByIdParams, ProcessBoundaryEventParams, UpdateBoundaryParams, UpsertBoundaryEventParams } from '../../types/boundaries';
+import { BaseRepository } from '../baseRepository';
+export declare class BoundariesRepository extends BaseRepository {
+    /**
+     * Get all boundaries by client id
+     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries by clientId
+     * - filters.clientId: The client id
+     * - filters.status: The status to only obtain boundaries with that status, optional
+     */
+    getBoundariesByClientId(params: GetBoundariesByClientIdParams): Promise<Boundary[]>;
+    /**
+     * Get all boundaries ids by client id
+     * @param  {GetBoundariesByClientIdParams} params containing information to get boundaries ids by clientId
+     * - filters.clientId: The client id
+     * - filters.status: The status to only obtain boundaries with that status, optional
+     */
+    getBoundariesIdsByClientId(params: GetBoundariesByClientIdParams): Promise<number[]>;
+    /**
+     * Get a boundary by id
+     * @param  {GetBoundaryByIdParams} params containing information to get a boundary by id
+     * - filters.boundaryId: The boundary id
+     */
+    getBoundaryById(params: GetBoundaryByIdParams): Promise<Boundary>;
+    /**
+     * Create a boundary
+     * @param  {CreateBoundaryParams} params containing information to create a boundary
+     * - name: boundary name
+     * - type: boundary type
+     * - clientId: id of the client that owns the boundary
+     * - createdBy: id of the user that created the boundary
+     * - location: location of the boundary
+     * - buffer: buffer of the boundary
+     * - radiusDisplayUnit: radius display unit of the boundary
+     * - color: color of the boundary
+     * - geometry: geometry of the boundary
+     * - status: status of the boundary
+     * - dataSourceTypeId: data source type id of the boundary, optional
+     * - isUserCreated: if the boundary was created by a user, optional
+     * - area: area of the boundary, optional
+     */
+    createBoundary(params: CreateBoundaryParams): Promise<Boundary>;
+    /**
+     * Update a boundary
+     * @param  {UpdateBoundaryParams} params containing information to update a boundary
+     * - filters.boundaryId: The id of the boundary to update
+     * - values.name: The name of the boundary. Optional, if undefined, the name will not be updated.
+     * - values.type: The type of the boundary. Optional, if undefined, the type will not be updated.
+     * - values.modifiedBy: The user id of the user that modified the boundary. Optional, if undefined, the modifiedBy will not be updated.
+     * - values.location: The location of the boundary. Optional, if undefined, the location will not be updated.
+     * - values.geometry: The geometry of the boundary. Optional, if undefined, the geometry will not be updated.
+     * - values.status: The status of the boundary. Optional, if undefined, the status will not be updated.
+     * - values.buffer: The buffer of the boundary. Optional, if undefined, the buffer will not be updated.
+     * - values.radiusDisplayUnit: The radius display unit of the boundary. Optional, if undefined, the radius display unit will not be updated.
+     * - values.color: The color of the boundary. Optional, if undefined, the color will not be updated.
+     * - values.area: The area of the boundary. Optional, if undefined, the area will not be updated.
+     */
+    updateBoundary(params: UpdateBoundaryParams): Promise<boolean>;
+    /**
+     * Delete a boundary
+     * @param  {DeleteBoundaryParams} params containing information to delete a boundary
+     * The boundary will not be removed from the database, it will only be marked as deleted
+     * - filters.boundaryId: The id of the boundary to delete
+     * - values.modifiedBy: The user id of the user that deleted the boundary
+     */
+    deleteBoundary(params: DeleteBoundaryParams): Promise<boolean>;
+    /**
+     * Get boundaries report
+     * @param  {GetBoundariesReportParams} params containing information to get boundaries report
+     * - filters.userId: The user id
+     * - filters.boundaryId: The boundary id, optional
+     * - filters.boundaryName: The boundary name, optional
+     * - filters.imeis: The imeis, optional
+     * - filters.boundaryInStartDate: The boundary in start date, optional
+     * - filters.boundaryInEndDate: The boundary in end date, optional
+     * - filters.boundaryOutStartDate: The boundary out start date, optional
+     * - filters.boundaryOutEndDate: The boundary out end date, optional
+     * - pagingOptions.pageSize: The page size of the pagination, required
+     * - pagingOptions.pageIndex: The page index of the pagination, required
+     * - sortOptions.sortField: The field to sort the pagination, optional
+     * - sortOptions.sortOrder: The order to sort the pagination, optional
+     * @returns The boundaries report
+     */
+    getBoundariesReport(params: GetBoundariesReportParams): Promise<BoundariesReportEntity[]>;
+    /**
+     * Process boundary event
+     * @param  {ProcessBoundaryEventParams} params containing information to process boundary event
+     * - boundaryId: The boundary id
+     * - imei: The imei of the device
+     * - userId: The user id
+     * - sendTime: The event date
+     * - eventType: The event type (enter or exit)
+     * - lat: The latitude of the event
+     * - lon: The longitude of the event
+     * - address: The address of the event
+     * @returns true if the event was processed, false otherwise
+     */
+    processBoundaryEvent(params: ProcessBoundaryEventParams): Promise<boolean>;
+    /**
+     * Upsert boundary event
+     * @param  {UpsertBoundaryEventParams} params containing information to upsert boundary event
+     * - id: The id of the boundary event
+     * @returns true if the event was upserted, false otherwise
+     */
+    upsertBoundaryEvent(params: UpsertBoundaryEventParams): Promise<boolean>;
+}