@forge/storage 1.3.1 → 1.3.2-experimental-58938ba

package/out/__test__/list-api.test.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const query_api_1 = require("../query-api");
+const query_api_2 = require("../entity-storage/query-api");
 const conditions_1 = require("../conditions");
 const conditions_2 = require("../eap/conditions");
-describe('DefaultQueryBuilder', () => {
+const query_interfaces_1 = require("../query-interfaces");
+describe('DefaultQueryBuilder Untyped entities', () => {
     function newGlobalStorage() {
         return {
             list: jest.fn()
@@ -109,3 +111,540 @@ describe('DefaultQueryBuilder', () => {
         }));
     });
 });
+describe('DefaultQueryBuilder CustomEntities', () => {
+    function newGlobalStorage() {
+        return {
+            listCustomEntities: jest.fn()
+        };
+    }
+    it('should only have "entity" as option for default base query builder', () => {
+        const globalStorage = newGlobalStorage();
+        const baseQueryBuilderInstance = new query_api_2.CustomEntityBuilder(globalStorage);
+        expect(baseQueryBuilderInstance).toHaveProperty('entity');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('index');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('where');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('andFilter');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('orFilter');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('cursor');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('limit');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('getOne');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('getMany');
+        expect(baseQueryBuilderInstance).not.toHaveProperty('sortOrder');
+    });
+    it('should only have "index" as option once "entity" is initialized', () => {
+        const globalStorage = newGlobalStorage();
+        const baseQueryBuilderInstanceWithEntity = new query_api_2.CustomEntityBuilder(globalStorage).entity('books');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('entity');
+        expect(baseQueryBuilderInstanceWithEntity).toHaveProperty('index');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('where');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('andFilter');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('orFilter');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('cursor');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('limit');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('getOne');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('getMany');
+        expect(baseQueryBuilderInstanceWithEntity).not.toHaveProperty('sortOrder');
+    });
+    it('should have "where", "andFilter", "orFilter", "cursor", "limit", "sortOrder", "getOne", "getMany" as options once "index" is initialized', () => {
+        const globalStorage = newGlobalStorage();
+        const queryBuilderInstanceWithIndex = new query_api_2.CustomEntityBuilder(globalStorage).entity('books').index('by-key');
+        expect(queryBuilderInstanceWithIndex).not.toHaveProperty('entity');
+        expect(queryBuilderInstanceWithIndex).not.toHaveProperty('index');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('where');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('andFilter');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('orFilter');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('cursor');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('limit');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('sortOrder');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('getOne');
+        expect(queryBuilderInstanceWithIndex).toHaveProperty('getMany');
+    });
+    it('should not have "orFilter" once "andFilter" is used', () => {
+        const globalStorage = newGlobalStorage();
+        const queryBuilderInstanceWithAndFilter = new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-key')
+            .andFilter('first_name', conditions_2.FilterConditions.beginsWith('John'));
+        expect(queryBuilderInstanceWithAndFilter).not.toHaveProperty('entity');
+        expect(queryBuilderInstanceWithAndFilter).not.toHaveProperty('index');
+        expect(queryBuilderInstanceWithAndFilter).not.toHaveProperty('orFilter');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('where');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('andFilter');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('cursor');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('limit');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('sortOrder');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('getOne');
+        expect(queryBuilderInstanceWithAndFilter).toHaveProperty('getMany');
+    });
+    it('should not have "andFilter" once "orFilter" is used', () => {
+        const globalStorage = newGlobalStorage();
+        const queryBuilderInstanceWithOrFilter = new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-key')
+            .orFilter('first_name', conditions_2.FilterConditions.beginsWith('John'));
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('entity');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('index');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('andFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('where');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('orFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('cursor');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('limit');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('sortOrder');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getOne');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getMany');
+    });
+    it('should be able to call "where", "cursor", "limit", "getOne", "getMany" after chaining multiple "orFilter"', async () => {
+        const globalStorage = newGlobalStorage();
+        const queryBuilderInstanceWithOrFilter = new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating-and-year', {
+            partition: [2019, 'John']
+        })
+            .orFilter('author', conditions_2.FilterConditions.contains('Doyle'))
+            .orFilter('genre', conditions_2.FilterConditions.equalsTo('horror'))
+            .where(conditions_2.WhereConditions.beginsWith('harry'))
+            .cursor('DUMMY_CURSOR_1234')
+            .limit(10)
+            .sortOrder(query_interfaces_1.SortOrder.DESC);
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('entity');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('index');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('andFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('where');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('orFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('cursor');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('limit');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('sortOrder');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getOne');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getMany');
+        await queryBuilderInstanceWithOrFilter.getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            sort: query_interfaces_1.SortOrder.DESC,
+            entityName: 'books',
+            indexName: 'by-rating-and-year',
+            partition: [2019, 'John'],
+            filterOperator: 'or',
+            range: {
+                condition: 'BEGINS_WITH',
+                values: ['harry']
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'CONTAINS',
+                    values: ['Doyle']
+                },
+                {
+                    property: 'genre',
+                    condition: 'EQUAL_TO',
+                    values: ['horror']
+                }
+            ],
+            limit: 10,
+            cursor: 'DUMMY_CURSOR_1234'
+        }));
+    });
+    it('should be able to call "where", "cursor", "limit", "getOne", "getMany" after chaining multiple "andFilter"', async () => {
+        const globalStorage = newGlobalStorage();
+        const queryBuilderInstanceWithOrFilter = new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating-and-year', {
+            partition: [2019, 'John']
+        })
+            .andFilter('author', conditions_2.FilterConditions.contains('Doyle'))
+            .andFilter('genre', conditions_2.FilterConditions.equalsTo('horror'))
+            .where(conditions_2.WhereConditions.beginsWith('harry'))
+            .cursor('DUMMY_CURSOR_1234')
+            .limit(10)
+            .sortOrder(query_interfaces_1.SortOrder.DESC);
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('entity');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('index');
+        expect(queryBuilderInstanceWithOrFilter).not.toHaveProperty('orFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('where');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('andFilter');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('cursor');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('limit');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('sortOrder');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getOne');
+        expect(queryBuilderInstanceWithOrFilter).toHaveProperty('getMany');
+        await queryBuilderInstanceWithOrFilter.getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            sort: query_interfaces_1.SortOrder.DESC,
+            entityName: 'books',
+            indexName: 'by-rating-and-year',
+            partition: [2019, 'John'],
+            filterOperator: 'and',
+            range: {
+                condition: 'BEGINS_WITH',
+                values: ['harry']
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'CONTAINS',
+                    values: ['Doyle']
+                },
+                {
+                    property: 'genre',
+                    condition: 'EQUAL_TO',
+                    values: ['horror']
+                }
+            ],
+            limit: 10,
+            cursor: 'DUMMY_CURSOR_1234'
+        }));
+    });
+    it('should pass when BETWEEN filter and range are passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.between([1, 2]))
+            .andFilter('author', conditions_2.FilterConditions.between([3, 4]))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            range: {
+                condition: 'BETWEEN',
+                values: [1, 2]
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'BETWEEN',
+                    values: [3, 4]
+                }
+            ]
+        }));
+    });
+    it('should pass when BEGINS_WITH filter and range are passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.beginsWith(1))
+            .andFilter('author', conditions_2.FilterConditions.beginsWith(2))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            range: {
+                condition: 'BEGINS_WITH',
+                values: [1]
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'BEGINS_WITH',
+                    values: [2]
+                }
+            ]
+        }));
+    });
+    it('should pass when EXISTS filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating')
+            .andFilter('rating', conditions_2.FilterConditions.exists())
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-rating',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'EXISTS',
+                    values: [true]
+                }
+            ]
+        }));
+    });
+    it('should pass when DOES_NOT_EXIST filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating')
+            .andFilter('rating', conditions_2.FilterConditions.doesNotExist())
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-rating',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'NOT_EXISTS',
+                    values: [true]
+                }
+            ]
+        }));
+    });
+    it('should pass when GREATER_THAN filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.isGreaterThan(1))
+            .andFilter('rating', conditions_2.FilterConditions.isGreaterThan(1))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            range: {
+                condition: 'GREATER_THAN',
+                values: [1]
+            },
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'GREATER_THAN',
+                    values: [1]
+                }
+            ]
+        }));
+    });
+    it('should pass when GREATER_THAN_EQUAL_TO filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.isGreaterThanEqualTo(1))
+            .andFilter('rating', conditions_2.FilterConditions.isGreaterThanEqualTo(1))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            range: {
+                condition: 'GREATER_THAN_EQUAL_TO',
+                values: [1]
+            },
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'GREATER_THAN_EQUAL_TO',
+                    values: [1]
+                }
+            ]
+        }));
+    });
+    it('should pass when LESS_THAN filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.isLessThan(1))
+            .andFilter('rating', conditions_2.FilterConditions.isLessThan(1))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            range: {
+                condition: 'LESS_THAN',
+                values: [1]
+            },
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'LESS_THAN',
+                    values: [1]
+                }
+            ]
+        }));
+    });
+    it('should pass when LESS_THAN_EQUAL_TO filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.isLessThanEqualTo(1))
+            .andFilter('rating', conditions_2.FilterConditions.isLessThanEqualTo(1))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            range: {
+                condition: 'LESS_THAN_EQUAL_TO',
+                values: [1]
+            },
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'LESS_THAN_EQUAL_TO',
+                    values: [1]
+                }
+            ]
+        }));
+    });
+    it('should pass when CONTAINS filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .andFilter('rating', conditions_2.FilterConditions.contains('Conan'))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'CONTAINS',
+                    values: ['Conan']
+                }
+            ]
+        }));
+    });
+    it('should pass when NOT_CONTAINS filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .andFilter('rating', conditions_2.FilterConditions.doesNotContain('Conan'))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'NOT_CONTAINS',
+                    values: ['Conan']
+                }
+            ]
+        }));
+    });
+    it('should pass when EQUAL_TO filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .andFilter('rating', conditions_2.FilterConditions.equalsTo('Conan'))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'EQUAL_TO',
+                    values: ['Conan']
+                }
+            ]
+        }));
+    });
+    it('should pass when NOT_EQUAL_TO filter is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .andFilter('rating', conditions_2.FilterConditions.notEqualsTo('Conan'))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'and',
+            filters: [
+                {
+                    property: 'rating',
+                    condition: 'NOT_EQUAL_TO',
+                    values: ['Conan']
+                }
+            ]
+        }));
+    });
+    it('should pass when filter operator is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-author')
+            .where(conditions_2.WhereConditions.between([1, 2]))
+            .orFilter('author', conditions_2.FilterConditions.between([3, 4]))
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            entityName: 'books',
+            indexName: 'by-author',
+            filterOperator: 'or',
+            range: {
+                condition: 'BETWEEN',
+                values: [1, 2]
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'BETWEEN',
+                    values: [3, 4]
+                }
+            ]
+        }));
+    });
+    it('should pass when ASC sort is passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating-and-year', {
+            partition: [2019]
+        })
+            .where(conditions_2.WhereConditions.between([1, 2]))
+            .sortOrder(query_interfaces_1.SortOrder.ASC)
+            .limit(10)
+            .cursor('DUMMY_CURSOR_1234')
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            sort: query_interfaces_1.SortOrder.ASC,
+            entityName: 'books',
+            indexName: 'by-rating-and-year',
+            partition: [2019],
+            range: {
+                condition: 'BETWEEN',
+                values: [1, 2]
+            },
+            limit: 10,
+            cursor: 'DUMMY_CURSOR_1234'
+        }));
+    });
+    it('should pass when All entity queries operator are passed', async () => {
+        const globalStorage = newGlobalStorage();
+        await new query_api_2.CustomEntityBuilder(globalStorage)
+            .entity('books')
+            .index('by-rating-and-year', {
+            partition: [2019, 'John']
+        })
+            .where(conditions_2.WhereConditions.between([1, 2]))
+            .sortOrder(query_interfaces_1.SortOrder.DESC)
+            .orFilter('author', conditions_2.FilterConditions.contains('Doyle'))
+            .limit(10)
+            .cursor('DUMMY_CURSOR_1234')
+            .getMany();
+        expect(globalStorage.listCustomEntities).toHaveBeenCalledWith(expect.objectContaining({
+            sort: query_interfaces_1.SortOrder.DESC,
+            entityName: 'books',
+            indexName: 'by-rating-and-year',
+            partition: [2019, 'John'],
+            filterOperator: 'or',
+            range: {
+                condition: 'BETWEEN',
+                values: [1, 2]
+            },
+            filters: [
+                {
+                    property: 'author',
+                    condition: 'CONTAINS',
+                    values: ['Doyle']
+                }
+            ],
+            limit: 10,
+            cursor: 'DUMMY_CURSOR_1234'
+        }));
+    });
+});

package/out/eap/conditions.d.ts

@@ -1,4 +1,40 @@
-import { Predicate } from '../storage-adapter';
+import { FilterPredicate, WherePredicate, Predicate } from '../storage-adapter';
 export declare function isNotEqualTo(value: string[]): Predicate;
 export declare function isIn(values: string[]): Predicate;
+declare function beginsWith(value: string | number): WherePredicate;
+declare function between(values: [string, string] | [number, number]): WherePredicate;
+declare function exists(): FilterPredicate;
+declare function doesNotExist(): FilterPredicate;
+declare function isGreaterThan(value: string | number): WherePredicate;
+declare function isGreaterThanEqualTo(value: string | number): WherePredicate;
+declare function isLessThan(value: string | number): WherePredicate;
+declare function isLessThanEqualTo(value: string | number): WherePredicate;
+declare function contains(value: string): FilterPredicate;
+declare function doesNotContain(value: string): FilterPredicate;
+declare function equalsTo(value: number | string | boolean): WherePredicate;
+declare function notEqualsTo(value: number | string | boolean): FilterPredicate;
+export declare const WhereConditions: {
+    beginsWith: typeof beginsWith;
+    between: typeof between;
+    equalsTo: typeof equalsTo;
+    isGreaterThan: typeof isGreaterThan;
+    isGreaterThanEqualTo: typeof isGreaterThanEqualTo;
+    isLessThan: typeof isLessThan;
+    isLessThanEqualTo: typeof isLessThanEqualTo;
+};
+export declare const FilterConditions: {
+    beginsWith: typeof beginsWith;
+    between: typeof between;
+    contains: typeof contains;
+    doesNotContain: typeof doesNotContain;
+    equalsTo: typeof equalsTo;
+    notEqualsTo: typeof notEqualsTo;
+    exists: typeof exists;
+    doesNotExist: typeof doesNotExist;
+    isGreaterThan: typeof isGreaterThan;
+    isGreaterThanEqualTo: typeof isGreaterThanEqualTo;
+    isLessThan: typeof isLessThan;
+    isLessThanEqualTo: typeof isLessThanEqualTo;
+};
+export {};
 //# sourceMappingURL=conditions.d.ts.map

package/out/eap/conditions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/eap/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAKvD;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,CAKhD"}
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/eap/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAChF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAKvD;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,CAKhD;AAKD,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAK1D;AAED,iBAAS,OAAO,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAK5E;AAED,iBAAS,MAAM,IAAI,eAAe,CAKjC;AAED,iBAAS,YAAY,IAAI,eAAe,CAKvC;AAED,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAK7D;AAED,iBAAS,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAKpE;AAED,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAK1D;AAED,iBAAS,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,CAKjE;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAKhD;AAED,iBAAS,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAKtD;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,cAAc,CAKlE;AAED,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAKtE;AAED,eAAO,MAAM,eAAe;;;;;;;;CAQ3B,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAa5B,CAAC"}