@spytecgps/nova-orm 1.2.23 → 1.2.24

package/dist/repositories/entityTags/index.js

@@ -1,104 +1,104 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { BaseRepository } from '../baseRepository';
-import { bulkCreateEntityTag } from './bulkCreateEntityTag';
-import { bulkDeleteEntityTag } from './bulkDeleteEntityTag';
-import { createEntityTag } from './createEntityTag';
-import { deleteEntityTag } from './deleteEntityTag';
-import { deleteEntityTagById } from './deleteEntityTagById';
-import { enforceEntityTagsByEntity } from './enforceEntityTagsByEntity';
-import { getEntityTagById } from './getEntityTagById';
-import { searchEntityTags } from './searchEntityTags';
-export class EntityTagsRepository extends BaseRepository {
-    /**
-     * Create a new entity tag
-     * @param {CreateEntityTagParams} params The parameters to create the entity tag
-     * @returns {EntityTag} The created entity tag
-     */
-    async createEntityTag(params) {
-        this.logger.trace(params, `EntityTagsRepository::createEntityTag started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const result = await createEntityTag(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'EntityTagsRepository::createEntityTag result');
-        return result;
-    }
-    /**
-     * Create multiple entity tags
-     * @param {CreateEntityTagParams[]} params The parameters to create the entity tags
-     * @returns {EntityTag[]} The created entity tags
-     */
-    async bulkCreateEntityTag(params) {
-        this.logger.trace(params, `EntityTagsRepository::bulkCreateEntityTag started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const results = await bulkCreateEntityTag(novaDataSource, params, this.logger);
-        this.logger.trace(results, 'EntityTagsRepository::bulkCreateEntityTag result');
-        return results;
-    }
-    /**
-     * Delete an entity tag
-     * @param {DeleteEntityTagParams} params The parameters to delete the entity tag
-     * @returns {boolean} Whether the entity tag was deleted
-     */
-    async deleteEntityTag(params) {
-        this.logger.trace(params, `EntityTagsRepository::deleteEntityTag started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const result = await deleteEntityTag(novaDataSource, params, this.logger);
-        this.logger.trace({ wasDeleted: result }, 'EntityTagsRepository::deleteEntityTag result');
-        return result;
-    }
-    /**
-     * Search for entity tags
-     * @param {SearchEntityTagsParams} params The parameters to search for entity tags
-     * @returns {GetEntityTagsResult} The results of the search
-     */
-    async searchEntityTags(params) {
-        this.logger.trace(params, `EntityTagsRepository::searchEntityTags started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await searchEntityTags(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'EntityTagsRepository::searchEntityTags result');
-        return result;
-    }
-    /**
-     * Delete multiple entity tags
-     * @param {BulkDeleteParams} params The parameters to delete the entity tags
-     * @returns {boolean} Whether the entity tags were deleted
-     */
-    async bulkDeleteEntityTag(params) {
-        this.logger.trace(params, `EntityTagsRepository::bulkDeleteEntityTag started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const wasDeleted = await bulkDeleteEntityTag(novaDataSource, params, this.logger);
-        this.logger.trace({ wasDeleted }, 'EntityTagsRepository::bulkDeleteEntityTag result');
-        return wasDeleted;
-    }
-    /**
-     * Enforce entity tags by entity
-     * @param {EnforceEntityTagsByEntityParams} params The parameters to enforce entity tags by entity
-     * @returns {GetEntityTagsResult} The results of the enforcement
-     */
-    async enforceEntityTagsByEntity(params) {
-        this.logger.trace(params, `EntityTagsRepository::enforceEntityTagsByEntity started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const result = await enforceEntityTagsByEntity(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'EntityTagsRepository::enforceEntityTagsByEntity result');
-        return result;
-    }
-    /**
-     * Delete an entity tag by id
-     * @param {number} id The id of the entity tag to delete
-     * @returns {boolean} Whether the entity tag was deleted
-     */
-    async deleteEntityTagById(id) {
-        this.logger.trace({ id }, `EntityTagsRepository::deleteEntityTagById started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const result = await deleteEntityTagById(novaDataSource, id, this.logger);
-        this.logger.trace({ wasDeleted: result }, 'EntityTagsRepository::deleteEntityTagById result');
-        return result;
-    }
-    async getEntityTagById(params) {
-        this.logger.trace({ params }, `EntityTagsRepository::getEntityTagById started with params`);
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
-        const result = await getEntityTagById(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'EntityTagsRepository::getEntityTagById result');
-        return result;
-    }
-}
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { bulkCreateEntityTag } from './bulkCreateEntityTag';
+import { bulkDeleteEntityTag } from './bulkDeleteEntityTag';
+import { createEntityTag } from './createEntityTag';
+import { deleteEntityTag } from './deleteEntityTag';
+import { deleteEntityTagById } from './deleteEntityTagById';
+import { enforceEntityTagsByEntity } from './enforceEntityTagsByEntity';
+import { getEntityTagById } from './getEntityTagById';
+import { searchEntityTags } from './searchEntityTags';
+export class EntityTagsRepository extends BaseRepository {
+    /**
+     * Create a new entity tag
+     * @param {CreateEntityTagParams} params The parameters to create the entity tag
+     * @returns {EntityTag} The created entity tag
+     */
+    async createEntityTag(params) {
+        this.logger.trace(params, `EntityTagsRepository::createEntityTag started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createEntityTag(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'EntityTagsRepository::createEntityTag result');
+        return result;
+    }
+    /**
+     * Create multiple entity tags
+     * @param {CreateEntityTagParams[]} params The parameters to create the entity tags
+     * @returns {EntityTag[]} The created entity tags
+     */
+    async bulkCreateEntityTag(params) {
+        this.logger.trace(params, `EntityTagsRepository::bulkCreateEntityTag started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const results = await bulkCreateEntityTag(novaDataSource, params, this.logger);
+        this.logger.trace(results, 'EntityTagsRepository::bulkCreateEntityTag result');
+        return results;
+    }
+    /**
+     * Delete an entity tag
+     * @param {DeleteEntityTagParams} params The parameters to delete the entity tag
+     * @returns {boolean} Whether the entity tag was deleted
+     */
+    async deleteEntityTag(params) {
+        this.logger.trace(params, `EntityTagsRepository::deleteEntityTag started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteEntityTag(novaDataSource, params, this.logger);
+        this.logger.trace({ wasDeleted: result }, 'EntityTagsRepository::deleteEntityTag result');
+        return result;
+    }
+    /**
+     * Search for entity tags
+     * @param {SearchEntityTagsParams} params The parameters to search for entity tags
+     * @returns {GetEntityTagsResult} The results of the search
+     */
+    async searchEntityTags(params) {
+        this.logger.trace(params, `EntityTagsRepository::searchEntityTags started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const result = await searchEntityTags(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'EntityTagsRepository::searchEntityTags result');
+        return result;
+    }
+    /**
+     * Delete multiple entity tags
+     * @param {BulkDeleteParams} params The parameters to delete the entity tags
+     * @returns {boolean} Whether the entity tags were deleted
+     */
+    async bulkDeleteEntityTag(params) {
+        this.logger.trace(params, `EntityTagsRepository::bulkDeleteEntityTag started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const wasDeleted = await bulkDeleteEntityTag(novaDataSource, params, this.logger);
+        this.logger.trace({ wasDeleted }, 'EntityTagsRepository::bulkDeleteEntityTag result');
+        return wasDeleted;
+    }
+    /**
+     * Enforce entity tags by entity
+     * @param {EnforceEntityTagsByEntityParams} params The parameters to enforce entity tags by entity
+     * @returns {GetEntityTagsResult} The results of the enforcement
+     */
+    async enforceEntityTagsByEntity(params) {
+        this.logger.trace(params, `EntityTagsRepository::enforceEntityTagsByEntity started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await enforceEntityTagsByEntity(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'EntityTagsRepository::enforceEntityTagsByEntity result');
+        return result;
+    }
+    /**
+     * Delete an entity tag by id
+     * @param {number} id The id of the entity tag to delete
+     * @returns {boolean} Whether the entity tag was deleted
+     */
+    async deleteEntityTagById(id) {
+        this.logger.trace({ id }, `EntityTagsRepository::deleteEntityTagById started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteEntityTagById(novaDataSource, id, this.logger);
+        this.logger.trace({ wasDeleted: result }, 'EntityTagsRepository::deleteEntityTagById result');
+        return result;
+    }
+    async getEntityTagById(params) {
+        this.logger.trace({ params }, `EntityTagsRepository::getEntityTagById started with params`);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getEntityTagById(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'EntityTagsRepository::getEntityTagById result');
+        return result;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/repositories/entityTags/searchEntityTags.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { GetEntityTagsResult, SearchEntityTagsParams } from '../../types/entitiesTags';
-import { Logger } from '../../types/logger';
-export declare const searchEntityTags: (novaDataSource: NovaDataSource, params: SearchEntityTagsParams, logger: Logger) => Promise<GetEntityTagsResult>;
+import { NovaDataSource } from '../../novaDataSource';
+import { GetEntityTagsResult, SearchEntityTagsParams } from '../../types/entitiesTags';
+import { Logger } from '../../types/logger';
+export declare const searchEntityTags: (novaDataSource: NovaDataSource, params: SearchEntityTagsParams, logger: Logger) => Promise<GetEntityTagsResult>;

package/dist/repositories/entityTags/searchEntityTags.js

@@ -1,46 +1,46 @@
-import { EntityTag } from '../../entities';
-import { requiredSearchEntityTagsParamsAttributes, } from '../../types/entitiesTags';
-import { anyAttributeIsNull } from '../../utils/paramsValidators';
-export const searchEntityTags = async (novaDataSource, params, logger) => {
-    if (anyAttributeIsNull(params, requiredSearchEntityTagsParamsAttributes)) {
-        logger.warn({ params }, 'EntityTagsRepository::searchEntityTags missing required parameters');
-        return { entitiesTags: [], totalCount: 0 };
-    }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
-        const tagsRepository = dataSource.getRepository(EntityTag);
-        const { filters, pagingOptions } = params;
-        let queryBuilder = tagsRepository
-            .createQueryBuilder()
-            .where('clientId = :clientId', { clientId: filters.clientId });
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        if (filters.entityIds?.length) {
-            queryBuilder = queryBuilder.andWhere('entityId IN (:...entityIds)', {
-                entityIds: filters.entityIds,
-            });
-        }
-        if (filters.tagIds?.length) {
-            queryBuilder = queryBuilder.andWhere('tagId IN (:...tagIds)', { tagIds: filters.tagIds });
-        }
-        if (filters.entityTypes?.length) {
-            queryBuilder = queryBuilder.andWhere('entityType IN (:...entityTypes)', {
-                entityTypes: filters.entityTypes,
-            });
-        }
-        // counting before applying pagination
-        const tagCount = await queryBuilder.getCount();
-        const limit = pagingOptions?.pageSize ?? 50;
-        queryBuilder.limit(limit);
-        const globalIndex = (pagingOptions?.pageIndex ?? 0) * limit;
-        queryBuilder.offset(globalIndex);
-        const entitiesTags = await queryBuilder.getMany();
-        return {
-            entitiesTags,
-            totalCount: tagCount,
-        };
-    }, 'EntityTagsRepository::searchEntityTags', dbQueryRunner);
-};
+import { EntityTag } from '../../entities';
+import { requiredSearchEntityTagsParamsAttributes, } from '../../types/entitiesTags';
+import { anyAttributeIsNull } from '../../utils/paramsValidators';
+export const searchEntityTags = async (novaDataSource, params, logger) => {
+    if (anyAttributeIsNull(params, requiredSearchEntityTagsParamsAttributes)) {
+        logger.warn({ params }, 'EntityTagsRepository::searchEntityTags missing required parameters');
+        return { entitiesTags: [], totalCount: 0 };
+    }
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+        const tagsRepository = dataSource.getRepository(EntityTag);
+        const { filters, pagingOptions } = params;
+        let queryBuilder = tagsRepository
+            .createQueryBuilder()
+            .where('clientId = :clientId', { clientId: filters.clientId });
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        if (filters.entityIds?.length) {
+            queryBuilder = queryBuilder.andWhere('entityId IN (:...entityIds)', {
+                entityIds: filters.entityIds,
+            });
+        }
+        if (filters.tagIds?.length) {
+            queryBuilder = queryBuilder.andWhere('tagId IN (:...tagIds)', { tagIds: filters.tagIds });
+        }
+        if (filters.entityTypes?.length) {
+            queryBuilder = queryBuilder.andWhere('entityType IN (:...entityTypes)', {
+                entityTypes: filters.entityTypes,
+            });
+        }
+        // counting before applying pagination
+        const tagCount = await queryBuilder.getCount();
+        const limit = pagingOptions?.pageSize ?? 50;
+        queryBuilder.limit(limit);
+        const globalIndex = (pagingOptions?.pageIndex ?? 0) * limit;
+        queryBuilder.offset(globalIndex);
+        const entitiesTags = await queryBuilder.getMany();
+        return {
+            entitiesTags,
+            totalCount: tagCount,
+        };
+    }, 'EntityTagsRepository::searchEntityTags', dbQueryRunner);
+};
 //# sourceMappingURL=searchEntityTags.js.map

package/dist/repositories/features/createFeature.d.ts

@@ -1,5 +1,5 @@
-import { Feature } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { CreateFeatureParams } from '../../types/feature';
-import { Logger } from '../../types/logger';
-export declare const createFeature: (novaDataSource: NovaDataSource, params: CreateFeatureParams, logger: Logger) => Promise<Feature>;
+import { Feature } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { CreateFeatureParams } from '../../types/feature';
+import { Logger } from '../../types/logger';
+export declare const createFeature: (novaDataSource: NovaDataSource, params: CreateFeatureParams, logger: Logger) => Promise<Feature>;

package/dist/repositories/features/createFeature.js

@@ -1,21 +1,21 @@
-import { Feature } from '../../entities';
-import { requiredCreateFeatureParamsAttributes } from '../../types/feature';
-import { anyAttributeIsNull } from '../../utils/paramsValidators';
-export const createFeature = async (novaDataSource, params, logger) => {
-    if (anyAttributeIsNull(params, requiredCreateFeatureParamsAttributes)) {
-        logger.warn({ params }, 'FeatureRepository::createFeature missing required parameters');
-        return null;
-    }
-    return novaDataSource.safeQuery(async (safeDataSource) => {
-        const featuresRepository = safeDataSource.getRepository(Feature);
-        const newFeature = {
-            key: params.key,
-            name: params.name,
-            description: params.description,
-            tags: params.tags,
-        };
-        const createdFeature = await featuresRepository.save(newFeature);
-        return createdFeature ?? null;
-    }, 'FeatureRepository::createFeature error');
-};
+import { Feature } from '../../entities';
+import { requiredCreateFeatureParamsAttributes } from '../../types/feature';
+import { anyAttributeIsNull } from '../../utils/paramsValidators';
+export const createFeature = async (novaDataSource, params, logger) => {
+    if (anyAttributeIsNull(params, requiredCreateFeatureParamsAttributes)) {
+        logger.warn({ params }, 'FeatureRepository::createFeature missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (safeDataSource) => {
+        const featuresRepository = safeDataSource.getRepository(Feature);
+        const newFeature = {
+            key: params.key,
+            name: params.name,
+            description: params.description,
+            tags: params.tags,
+        };
+        const createdFeature = await featuresRepository.save(newFeature);
+        return createdFeature ?? null;
+    }, 'FeatureRepository::createFeature error');
+};
 //# sourceMappingURL=createFeature.js.map

package/dist/repositories/features/deleteFeature.d.ts

@@ -1,4 +1,4 @@
-import { NovaDataSource } from '../../novaDataSource';
-import { DeleteFeatureParams } from '../../types/feature';
-import { Logger } from '../../types/logger';
-export declare const deleteFeature: (novaDataSource: NovaDataSource, params: DeleteFeatureParams, logger: Logger) => Promise<boolean>;
+import { NovaDataSource } from '../../novaDataSource';
+import { DeleteFeatureParams } from '../../types/feature';
+import { Logger } from '../../types/logger';
+export declare const deleteFeature: (novaDataSource: NovaDataSource, params: DeleteFeatureParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/features/deleteFeature.js

@@ -1,17 +1,17 @@
-import { Feature } from '../../entities';
-export const deleteFeature = async (novaDataSource, params, logger) => {
-    if (!params?.filters?.key) {
-        logger.warn({ params }, 'FeatureRepository::deleteFeature missing required parameters');
-        return false;
-    }
-    return novaDataSource.safeQuery(async (dataSource) => {
-        const featureRepository = dataSource.getRepository(Feature);
-        const result = await featureRepository
-            .createQueryBuilder()
-            .delete()
-            .where('key = :key', { key: params.filters.key })
-            .execute();
-        return result.affected > 0;
-    }, 'FeatureRepository::deleteFeature');
-};
+import { Feature } from '../../entities';
+export const deleteFeature = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.key) {
+        logger.warn({ params }, 'FeatureRepository::deleteFeature missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const featureRepository = dataSource.getRepository(Feature);
+        const result = await featureRepository
+            .createQueryBuilder()
+            .delete()
+            .where('key = :key', { key: params.filters.key })
+            .execute();
+        return result.affected > 0;
+    }, 'FeatureRepository::deleteFeature');
+};
 //# sourceMappingURL=deleteFeature.js.map

package/dist/repositories/features/getFeatures.d.ts

@@ -1,4 +1,4 @@
-import { Feature } from '../../entities';
-import { NovaDataSource } from '../../novaDataSource';
-import { GetFeatureParams } from '../../types/feature';
-export declare const getFeatures: (novaDataSource: NovaDataSource, params: GetFeatureParams) => Promise<Feature[]>;
+import { Feature } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { GetFeatureParams } from '../../types/feature';
+export declare const getFeatures: (novaDataSource: NovaDataSource, params: GetFeatureParams) => Promise<Feature[]>;

package/dist/repositories/features/getFeatures.js

@@ -1,25 +1,25 @@
-import { Feature } from '../../entities';
-export const getFeatures = async (novaDataSource, params) => {
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (safeDataSource, queryRunner) => {
-        const featureRepository = safeDataSource.getRepository(Feature);
-        const queryBuilder = featureRepository.createQueryBuilder('feature');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
-        if (params?.filters?.keys?.length) {
-            queryBuilder.where('feature.key IN (:keyList)', {
-                keyList: params.filters.keys,
-            });
-        }
-        if (params?.filters?.names?.length) {
-            queryBuilder.andWhere('feature.name IN (:nameList)', {
-                nameList: params.filters.names,
-            });
-        }
-        const features = await queryBuilder.getMany();
-        return features?.length ? features : [];
-    }, 'FeatureRepository::getFeatures error', dbQueryRunner);
-};
+import { Feature } from '../../entities';
+export const getFeatures = async (novaDataSource, params) => {
+    // Force the query to run on master or slave
+    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
+    return novaDataSource.safeQuery(async (safeDataSource, queryRunner) => {
+        const featureRepository = safeDataSource.getRepository(Feature);
+        const queryBuilder = featureRepository.createQueryBuilder('feature');
+        if (queryRunner) {
+            queryBuilder.setQueryRunner(queryRunner);
+        }
+        if (params?.filters?.keys?.length) {
+            queryBuilder.where('feature.key IN (:keyList)', {
+                keyList: params.filters.keys,
+            });
+        }
+        if (params?.filters?.names?.length) {
+            queryBuilder.andWhere('feature.name IN (:nameList)', {
+                nameList: params.filters.names,
+            });
+        }
+        const features = await queryBuilder.getMany();
+        return features?.length ? features : [];
+    }, 'FeatureRepository::getFeatures error', dbQueryRunner);
+};
 //# sourceMappingURL=getFeatures.js.map

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

@@ -1,33 +1,33 @@
-import { Feature } from '../../entities';
-import { CreateFeatureParams, DeleteFeatureParams, GetFeatureParams } from '../../types/feature';
-import { BaseRepository } from '../baseRepository';
-/**
- * FeatureRepository, used to interact with the feature entity
- * @extends BaseRepository
- */
-export declare class FeatureRepository extends BaseRepository {
-    /**
-     * Create a feature
-     * @param  {CreateFeatureParams} params containing information to create a feature
-     * @returns {Feature} the created feature
-     * */
-    createFeature(params: CreateFeatureParams): Promise<Feature>;
-    /**
-     * Get features
-     * @param  {GetFeatureParams} params containing information to get features
-     * @returns {Feature[]} the features
-     */
-    getFeatures(params?: GetFeatureParams): Promise<Feature[]>;
-    /**
-     * Upsert a feature
-     * @param  {CreateFeatureParams} params containing information to update a feature
-     * @returns {Feature} the updated feature
-     * */
-    upsertFeature(params: CreateFeatureParams): Promise<boolean>;
-    /**
-     * Delete a feature
-     * @param  {DeleteFeatureParams} params containing information to delete a feature
-     * @returns {boolean} if the feature was deleted
-     * */
-    deleteFeature(params: DeleteFeatureParams): Promise<boolean>;
-}
+import { Feature } from '../../entities';
+import { CreateFeatureParams, DeleteFeatureParams, GetFeatureParams } from '../../types/feature';
+import { BaseRepository } from '../baseRepository';
+/**
+ * FeatureRepository, used to interact with the feature entity
+ * @extends BaseRepository
+ */
+export declare class FeatureRepository extends BaseRepository {
+    /**
+     * Create a feature
+     * @param  {CreateFeatureParams} params containing information to create a feature
+     * @returns {Feature} the created feature
+     * */
+    createFeature(params: CreateFeatureParams): Promise<Feature>;
+    /**
+     * Get features
+     * @param  {GetFeatureParams} params containing information to get features
+     * @returns {Feature[]} the features
+     */
+    getFeatures(params?: GetFeatureParams): Promise<Feature[]>;
+    /**
+     * Upsert a feature
+     * @param  {CreateFeatureParams} params containing information to update a feature
+     * @returns {Feature} the updated feature
+     * */
+    upsertFeature(params: CreateFeatureParams): Promise<boolean>;
+    /**
+     * Delete a feature
+     * @param  {DeleteFeatureParams} params containing information to delete a feature
+     * @returns {boolean} if the feature was deleted
+     * */
+    deleteFeature(params: DeleteFeatureParams): Promise<boolean>;
+}