npm - @kinotic-ai/persistence - Versions diffs - 1.1.0 → 1.1.1 - Mend

@kinotic-ai/persistence 1.1.0 → 1.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.cjs CHANGED Viewed

@@ -268,62 +268,62 @@ class EntitiesRepository {
   constructor(kinotic) {
     this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.JsonEntitiesRepository");
   }
-  bulkSave(structureId, entities) {
-    return this.serviceProxy.invoke("bulkSave", [structureId, entities]);
+  bulkSave(entityDefinitionId, entities) {
+    return this.serviceProxy.invoke("bulkSave", [entityDefinitionId, entities]);
   }
-  bulkUpdate(structureId, entities) {
-    return this.serviceProxy.invoke("bulkUpdate", [structureId, entities]);
+  bulkUpdate(entityDefinitionId, entities) {
+    return this.serviceProxy.invoke("bulkUpdate", [entityDefinitionId, entities]);
   }
-  count(structureId) {
-    return this.serviceProxy.invoke("count", [structureId]);
+  count(entityDefinitionId) {
+    return this.serviceProxy.invoke("count", [entityDefinitionId]);
   }
-  countByQuery(structureId, query) {
-    return this.serviceProxy.invoke("countByQuery", [structureId, query]);
+  countByQuery(entityDefinitionId, query) {
+    return this.serviceProxy.invoke("countByQuery", [entityDefinitionId, query]);
   }
-  deleteById(structureId, id) {
-    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  deleteById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("deleteById", [entityDefinitionId, id]);
   }
-  deleteByQuery(structureId, query) {
-    return this.serviceProxy.invoke("deleteByQuery", [structureId, query]);
+  deleteByQuery(entityDefinitionId, query) {
+    return this.serviceProxy.invoke("deleteByQuery", [entityDefinitionId, query]);
   }
-  async findAll(structureId, pageable) {
-    const page = await this.findAllSinglePage(structureId, pageable);
-    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(structureId, pageable2));
+  async findAll(entityDefinitionId, pageable) {
+    const page = await this.findAllSinglePage(entityDefinitionId, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(entityDefinitionId, pageable2));
   }
-  async findAllSinglePage(structureId, pageable) {
-    return this.serviceProxy.invoke("findAll", [structureId, pageable]);
+  async findAllSinglePage(entityDefinitionId, pageable) {
+    return this.serviceProxy.invoke("findAll", [entityDefinitionId, pageable]);
   }
-  findById(structureId, id) {
-    return this.serviceProxy.invoke("findById", [structureId, id]);
+  findById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("findById", [entityDefinitionId, id]);
   }
-  findByIds(structureId, ids) {
-    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  findByIds(entityDefinitionId, ids) {
+    return this.serviceProxy.invoke("findByIds", [entityDefinitionId, ids]);
   }
-  namedQuery(structureId, queryName, parameters) {
-    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  namedQuery(entityDefinitionId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [entityDefinitionId, queryName, parameters]);
   }
-  async namedQueryPage(structureId, queryName, parameters, pageable) {
-    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
-    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  async namedQueryPage(entityDefinitionId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable2));
   }
-  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
-    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [entityDefinitionId, queryName, parameters, pageable]);
   }
-  save(structureId, entity) {
-    return this.serviceProxy.invoke("save", [structureId, entity]);
+  save(entityDefinitionId, entity) {
+    return this.serviceProxy.invoke("save", [entityDefinitionId, entity]);
   }
-  async search(structureId, searchText, pageable) {
-    const page = await this.searchSinglePage(structureId, searchText, pageable);
-    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, pageable2));
+  async search(entityDefinitionId, searchText, pageable) {
+    const page = await this.searchSinglePage(entityDefinitionId, searchText, pageable);
+    return new import_core.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(entityDefinitionId, searchText, pageable2));
   }
-  async searchSinglePage(structureId, searchText, pageable) {
-    return this.serviceProxy.invoke("search", [structureId, searchText, pageable]);
+  async searchSinglePage(entityDefinitionId, searchText, pageable) {
+    return this.serviceProxy.invoke("search", [entityDefinitionId, searchText, pageable]);
   }
-  async syncIndex(structureId) {
-    return this.serviceProxy.invoke("syncIndex", [structureId]);
+  async syncIndex(entityDefinitionId) {
+    return this.serviceProxy.invoke("syncIndex", [entityDefinitionId]);
   }
-  update(structureId, entity) {
-    return this.serviceProxy.invoke("update", [structureId, entity]);
+  update(entityDefinitionId, entity) {
+    return this.serviceProxy.invoke("update", [entityDefinitionId, entity]);
   }
 }
 // packages/persistence/src/api/IAdminEntitiesRepository.ts
@@ -334,47 +334,47 @@ class AdminEntitiesRepository {
   constructor(kinotic) {
     this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.AdminJsonEntitiesRepository");
   }
-  count(structureId, tenantSelection) {
-    return this.serviceProxy.invoke("count", [structureId, tenantSelection]);
+  count(entityDefinitionId, tenantSelection) {
+    return this.serviceProxy.invoke("count", [entityDefinitionId, tenantSelection]);
   }
-  countByQuery(structureId, query, tenantSelection) {
-    return this.serviceProxy.invoke("countByQuery", [structureId, query, tenantSelection]);
+  countByQuery(entityDefinitionId, query, tenantSelection) {
+    return this.serviceProxy.invoke("countByQuery", [entityDefinitionId, query, tenantSelection]);
   }
-  deleteById(structureId, id) {
-    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  deleteById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("deleteById", [entityDefinitionId, id]);
   }
-  deleteByQuery(structureId, query, tenantSelection) {
-    return this.serviceProxy.invoke("deleteByQuery", [structureId, query, tenantSelection]);
+  deleteByQuery(entityDefinitionId, query, tenantSelection) {
+    return this.serviceProxy.invoke("deleteByQuery", [entityDefinitionId, query, tenantSelection]);
   }
-  async findAll(structureId, tenantSelection, pageable) {
-    const page = await this.findAllSinglePage(structureId, tenantSelection, pageable);
-    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(structureId, tenantSelection, pageable2));
+  async findAll(entityDefinitionId, tenantSelection, pageable) {
+    const page = await this.findAllSinglePage(entityDefinitionId, tenantSelection, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(entityDefinitionId, tenantSelection, pageable2));
   }
-  async findAllSinglePage(structureId, tenantSelection, pageable) {
-    return this.serviceProxy.invoke("findAll", [structureId, tenantSelection, pageable]);
+  async findAllSinglePage(entityDefinitionId, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("findAll", [entityDefinitionId, tenantSelection, pageable]);
   }
-  findById(structureId, id) {
-    return this.serviceProxy.invoke("findById", [structureId, id]);
+  findById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("findById", [entityDefinitionId, id]);
   }
-  findByIds(structureId, ids) {
-    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  findByIds(entityDefinitionId, ids) {
+    return this.serviceProxy.invoke("findByIds", [entityDefinitionId, ids]);
   }
-  namedQuery(structureId, queryName, parameters) {
-    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  namedQuery(entityDefinitionId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [entityDefinitionId, queryName, parameters]);
   }
-  async namedQueryPage(structureId, queryName, parameters, pageable) {
-    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
-    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  async namedQueryPage(entityDefinitionId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable2));
   }
-  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
-    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [entityDefinitionId, queryName, parameters, pageable]);
   }
-  async search(structureId, searchText, tenantSelection, pageable) {
-    const page = await this.searchSinglePage(structureId, searchText, tenantSelection, pageable);
-    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, tenantSelection, pageable2));
+  async search(entityDefinitionId, searchText, tenantSelection, pageable) {
+    const page = await this.searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable2));
   }
-  async searchSinglePage(structureId, searchText, tenantSelection, pageable) {
-    return this.serviceProxy.invoke("search", [structureId, searchText, tenantSelection, pageable]);
+  async searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("search", [entityDefinitionId, searchText, tenantSelection, pageable]);
   }
 }
 // packages/persistence/src/api/IEntityRepository.ts
@@ -384,10 +384,10 @@ class EntityRepository {
   entityName;
   entityId;
   entitiesRepository;
-  constructor(structureApplicationId, structureName, entitiesRepository) {
-    this.entityApplicationId = structureApplicationId;
-    this.entityName = structureName;
-    this.entityId = (structureApplicationId + "." + structureName).toLowerCase();
+  constructor(entityApplicationId, entityName, entitiesRepository) {
+    this.entityApplicationId = entityApplicationId;
+    this.entityName = entityName;
+    this.entityId = (entityApplicationId + "." + entityName).toLowerCase();
     this.entitiesRepository = entitiesRepository ?? new EntitiesRepository(import_core3.Kinotic);
   }
   async bulkSave(entities) {
@@ -453,10 +453,10 @@ class AdminEntityRepository {
   entityName;
   entityId;
   adminEntitiesRepository;
-  constructor(structureApplicationId, structureName, adminEntitiesRepository) {
-    this.entityApplicationId = structureApplicationId;
-    this.entityName = structureName;
-    this.entityId = (structureApplicationId + "." + structureName).toLowerCase();
+  constructor(entityApplicationId, entityName, adminEntitiesRepository) {
+    this.entityApplicationId = entityApplicationId;
+    this.entityName = entityName;
+    this.entityId = (entityApplicationId + "." + entityName).toLowerCase();
     this.adminEntitiesRepository = adminEntitiesRepository ?? new AdminEntitiesRepository(import_core4.Kinotic);
   }
   count(tenantSelection) {

package/dist/index.d.cts CHANGED Viewed

@@ -210,166 +210,166 @@ import { IServiceProxy, Page, Pageable, IterablePage } from "@kinotic-ai/core";
 interface IEntitiesRepository {
 	/**
 	* Saves all given entities.
-	* @param structureId the id of the structure to save the entities for
+	* @param entityDefinitionId the id of the structure to save the entities for
 	* @param entities all the entities to save
 	* @return Promise that will complete when all entities have been saved
 	*/
-	bulkSave<T>(structureId: string, entities: T[]): Promise<void>;
+	bulkSave<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
 	/**
 	* Updates all given entities.
-	* @param structureId the id of the structure to update the entities for
+	* @param entityDefinitionId the id of the structure to update the entities for
 	* @param entities all the entities to save
 	* @return Promise that will complete when all entities have been saved
 	*/
-	bulkUpdate<T>(structureId: string, entities: T[]): Promise<void>;
+	bulkUpdate<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
 	/**
 	* Returns the number of entities available.
-	* @param structureId the id of the structure to count
+	* @param entityDefinitionId the id of the structure to count
 	* @return {@link Promise} emitting the number of entities.
 	*/
-	count(structureId: string): Promise<number>;
+	count(entityDefinitionId: string): Promise<number>;
 	/**
 	* Returns the number of entities available for the given query.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query       the query used to limit result
 	* @return Promise    emitting the number of entities
 	*/
-	countByQuery(structureId: string, query: string): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string): Promise<number>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} emitting when delete is complete
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	deleteById(structureId: string, id: string): Promise<void>;
+	deleteById(entityDefinitionId: string, id: string): Promise<void>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query      the query used to filter records to delete, must not be {@literal null}
 	* @return Promise signaling when operation has completed
 	* @throws Error in case the given {@literal query} is {@literal null}
 	*/
-	deleteByQuery(structureId: string, query: string): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string): Promise<void>;
 	/**
 	* Returns a {@link IterablePage} of entities meeting the paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	findAll<T>(structureId: string, pageable: Pageable): Promise<IterablePage<T>>;
+	findAll<T>(entityDefinitionId: string, pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Returns a single {@link Page} of entities meeting the paging restriction provided in the {@link Pageable} object.
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param pageable the page settings to be used
 	*/
-	findAllSinglePage<T>(structureId: string, pageable: Pageable): Promise<Page<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, pageable: Pageable): Promise<Page<T>>;
 	/**
 	* Retrieves an entity by its id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} with the entity with the given id or {@link Promise} emitting null if none found
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	findById<T>(structureId: string, id: string): Promise<T>;
+	findById<T>(entityDefinitionId: string, id: string): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param ids      must not be {@literal null}
 	* @return Promise emitting the entities with the given ids or Promise emitting null if none found
 	* @throws Error in case the given {@literal ids} is {@literal null}
 	*/
-	findByIds<T>(structureId: string, ids: string[]): Promise<T[]>;
+	findByIds<T>(entityDefinitionId: string, ids: string[]): Promise<T[]>;
 	/**
 	* Executes a named query.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @returns Promise with the result of the query
 	*/
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
 	/**
 	* Executes a named query and returns a Page of results.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @param pageable the page settings to be used
 	* @returns Promise with the result of the query
 	*/
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
 	* entity instance completely.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param entity      must not be {@literal null}
 	* @return {@link Promise} emitting the saved entity
 	* @throws IllegalArgumentException in case the given {@literal entity} is {@literal null}
 	*/
-	save<T>(structureId: string, entity: T): Promise<T>;
+	save<T>(entityDefinitionId: string, entity: T): Promise<T>;
 	/**
 	* Returns a {@link IterablePage} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	search<T>(structureId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Returns a single {@link Page} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	searchSinglePage<T>(structureId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
 	/**
 	* This operation makes all the recent writes immediately available for search.
-	* @param structureId the id of the structure to sync the index for.
+	* @param entityDefinitionId the id of the structure to sync the index for.
 	* @return a Promise that resolves when the operation is complete
 	*/
-	syncIndex(structureId: string): Promise<void>;
+	syncIndex(entityDefinitionId: string): Promise<void>;
 	/**
 	* Updates a given entity. This will only override the fields that are present in the given entity.
 	* If any fields are not present in the given entity data, they will not be changed.
 	* If the entity does not exist, it will be created.
 	*
-	* @param structureId the id of the structure to update the entity for
+	* @param entityDefinitionId the id of the structure to update the entity for
 	* @param entity      must not be {@literal null}
 	* @return Promise emitting the saved entity
 	* @throws Error in case the given {@literal entity} is {@literal null}
 	*/
-	update<T>(structureId: string, entity: T): Promise<T>;
+	update<T>(entityDefinitionId: string, entity: T): Promise<T>;
 }
 declare class EntitiesRepository implements IEntitiesRepository {
 	protected serviceProxy: IServiceProxy;
 	constructor(kinotic: IKinotic);
-	bulkSave<T>(structureId: string, entities: T[]): Promise<void>;
-	bulkUpdate<T>(structureId: string, entities: T[]): Promise<void>;
-	count(structureId: string): Promise<number>;
-	countByQuery(structureId: string, query: string): Promise<number>;
-	deleteById(structureId: string, id: string): Promise<void>;
-	deleteByQuery(structureId: string, query: string): Promise<void>;
-	findAll<T>(structureId: string, pageable: Pageable): Promise<IterablePage<T>>;
-	findAllSinglePage<T>(structureId: string, pageable: Pageable): Promise<Page<T>>;
-	findById<T>(structureId: string, id: string): Promise<T>;
-	findByIds<T>(structureId: string, ids: string[]): Promise<T[]>;
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
-	namedQuerySinglePage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<Page<T>>;
-	save<T>(structureId: string, entity: T): Promise<T>;
-	search<T>(structureId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
-	searchSinglePage<T>(structureId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
-	syncIndex(structureId: string): Promise<void>;
-	update<T>(structureId: string, entity: T): Promise<T>;
+	bulkSave<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
+	bulkUpdate<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
+	count(entityDefinitionId: string): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string): Promise<number>;
+	deleteById(entityDefinitionId: string, id: string): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string): Promise<void>;
+	findAll<T>(entityDefinitionId: string, pageable: Pageable): Promise<IterablePage<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, pageable: Pageable): Promise<Page<T>>;
+	findById<T>(entityDefinitionId: string, id: string): Promise<T | null>;
+	findByIds<T>(entityDefinitionId: string, ids: string[]): Promise<T[]>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
+	namedQuerySinglePage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<Page<T>>;
+	save<T>(entityDefinitionId: string, entity: T): Promise<T>;
+	search<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
+	syncIndex(entityDefinitionId: string): Promise<void>;
+	update<T>(entityDefinitionId: string, entity: T): Promise<T>;
 }
 import { IKinotic as IKinotic2 } from "@kinotic-ai/core";
 import { IServiceProxy as IServiceProxy2, Page as Page2, Pageable as Pageable2, IterablePage as IterablePage2 } from "@kinotic-ai/core";
@@ -381,106 +381,106 @@ interface IAdminEntitiesRepository {
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @return {@link Promise} emitting the number of entities.
 	*/
-	count(structureId: string, tenantSelection: TenantSelection): Promise<number>;
+	count(entityDefinitionId: string, tenantSelection: TenantSelection): Promise<number>;
 	/**
 	* Returns the number of entities available for the given query.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query       the query used to limit result
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @return Promise    emitting the number of entities
 	*/
-	countByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} emitting when delete is complete
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	deleteById(structureId: string, id: TenantSpecificId): Promise<void>;
+	deleteById(entityDefinitionId: string, id: TenantSpecificId): Promise<void>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query      the query used to filter records to delete, must not be {@literal null}
 	* @param tenantSelection the list of tenants to use when deleting the entity records
 	* @return Promise signaling when operation has completed
 	* @throws Error in case the given {@literal query} is {@literal null}
 	*/
-	deleteByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
 	/**
 	* Returns a {@link IterablePage} of entities meeting the paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	findAll<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	findAll<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
 	/**
 	* Retrieves an entity by its id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} with the entity with the given id or {@link Promise} emitting null if none found
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	findById<T>(structureId: string, id: TenantSpecificId): Promise<T>;
+	findById<T>(entityDefinitionId: string, id: TenantSpecificId): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param ids      must not be {@literal null}
 	* @return Promise emitting the entities with the given ids or Promise emitting null if none found
 	* @throws Error in case the given {@literal ids} is {@literal null}
 	*/
-	findByIds<T>(structureId: string, ids: TenantSpecificId[]): Promise<T[]>;
+	findByIds<T>(entityDefinitionId: string, ids: TenantSpecificId[]): Promise<T[]>;
 	/**
 	* Executes a named query.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @returns Promise with the result of the query
 	*/
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
 	/**
 	* Executes a named query and returns a Page of results.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @param pageable the page settings to be used
 	* @returns Promise with the result of the query
 	*/
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
 	/**
 	* Returns a {@link IterablePage} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	search<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
 }
 declare class AdminEntitiesRepository implements IAdminEntitiesRepository {
 	protected serviceProxy: IServiceProxy2;
 	constructor(kinotic: IKinotic2);
-	count(structureId: string, tenantSelection: TenantSelection): Promise<number>;
-	countByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
-	deleteById(structureId: string, id: TenantSpecificId): Promise<void>;
-	deleteByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
-	findAll<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
-	findAllSinglePage<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
-	findById<T>(structureId: string, id: TenantSpecificId): Promise<T>;
-	findByIds<T>(structureId: string, ids: TenantSpecificId[]): Promise<T[]>;
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
-	namedQuerySinglePage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<Page2<T>>;
-	search<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
-	searchSinglePage<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
+	count(entityDefinitionId: string, tenantSelection: TenantSelection): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
+	deleteById(entityDefinitionId: string, id: TenantSpecificId): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
+	findAll<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
+	findById<T>(entityDefinitionId: string, id: TenantSpecificId): Promise<T>;
+	findByIds<T>(entityDefinitionId: string, ids: TenantSpecificId[]): Promise<T[]>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
+	namedQuerySinglePage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<Page2<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
 }
 import { Pageable as Pageable3, IterablePage as IterablePage3 } from "@kinotic-ai/core";
 /**
@@ -556,7 +556,7 @@ interface IEntityRepository<T> {
 	* @return Promise emitting the entity with the given id or Promise emitting null if none found
 	* @throws Error in case the given {@literal id} is {@literal null}
 	*/
-	findById(id: string): Promise<T>;
+	findById(id: string): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
@@ -622,7 +622,7 @@ declare class EntityRepository<T> implements IEntityRepository<T> {
 	entityName: string;
 	entityId: string;
 	private readonly entitiesRepository;
-	constructor(structureApplicationId: string, structureName: string, entitiesRepository?: IEntitiesRepository);
+	constructor(entityApplicationId: string, entityName: string, entitiesRepository?: IEntitiesRepository);
 	bulkSave(entities: T[]): Promise<void>;
 	bulkUpdate(entities: T[]): Promise<void>;
 	count(): Promise<number>;
@@ -630,7 +630,7 @@ declare class EntityRepository<T> implements IEntityRepository<T> {
 	deleteById(id: string): Promise<void>;
 	deleteByQuery(query: string): Promise<void>;
 	findAll(pageable: Pageable3): Promise<IterablePage3<T>>;
-	findById(id: string): Promise<T>;
+	findById(id: string): Promise<T | null>;
 	findByIds(ids: string[]): Promise<T[]>;
 	namedQuery<U>(queryName: string, queryParameters: QueryParameter[]): Promise<U>;
 	namedQueryPage<U>(queryName: string, queryParameters: QueryParameter[], pageable: Pageable3): Promise<IterablePage3<U>>;
@@ -707,7 +707,7 @@ interface IAdminEntityRepository<T> {
 	* @return Promise emitting the entity with the given id or Promise emitting null if none found
 	* @throws Error in case the given {@literal id} is {@literal null}
 	*/
-	findById(id: TenantSpecificId): Promise<T>;
+	findById(id: TenantSpecificId): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
@@ -750,7 +750,7 @@ declare class AdminEntityRepository<T> implements IAdminEntityRepository<T> {
 	entityName: string;
 	entityId: string;
 	private readonly adminEntitiesRepository;
-	constructor(structureApplicationId: string, structureName: string, adminEntitiesRepository?: IAdminEntitiesRepository);
+	constructor(entityApplicationId: string, entityName: string, adminEntitiesRepository?: IAdminEntitiesRepository);
 	count(tenantSelection: TenantSelection): Promise<number>;
 	countByQuery(query: string, tenantSelection: TenantSelection): Promise<number>;
 	deleteById(id: TenantSpecificId): Promise<void>;

package/dist/index.d.ts CHANGED Viewed

@@ -210,166 +210,166 @@ import { IServiceProxy, Page, Pageable, IterablePage } from "@kinotic-ai/core";
 interface IEntitiesRepository {
 	/**
 	* Saves all given entities.
-	* @param structureId the id of the structure to save the entities for
+	* @param entityDefinitionId the id of the structure to save the entities for
 	* @param entities all the entities to save
 	* @return Promise that will complete when all entities have been saved
 	*/
-	bulkSave<T>(structureId: string, entities: T[]): Promise<void>;
+	bulkSave<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
 	/**
 	* Updates all given entities.
-	* @param structureId the id of the structure to update the entities for
+	* @param entityDefinitionId the id of the structure to update the entities for
 	* @param entities all the entities to save
 	* @return Promise that will complete when all entities have been saved
 	*/
-	bulkUpdate<T>(structureId: string, entities: T[]): Promise<void>;
+	bulkUpdate<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
 	/**
 	* Returns the number of entities available.
-	* @param structureId the id of the structure to count
+	* @param entityDefinitionId the id of the structure to count
 	* @return {@link Promise} emitting the number of entities.
 	*/
-	count(structureId: string): Promise<number>;
+	count(entityDefinitionId: string): Promise<number>;
 	/**
 	* Returns the number of entities available for the given query.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query       the query used to limit result
 	* @return Promise    emitting the number of entities
 	*/
-	countByQuery(structureId: string, query: string): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string): Promise<number>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} emitting when delete is complete
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	deleteById(structureId: string, id: string): Promise<void>;
+	deleteById(entityDefinitionId: string, id: string): Promise<void>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query      the query used to filter records to delete, must not be {@literal null}
 	* @return Promise signaling when operation has completed
 	* @throws Error in case the given {@literal query} is {@literal null}
 	*/
-	deleteByQuery(structureId: string, query: string): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string): Promise<void>;
 	/**
 	* Returns a {@link IterablePage} of entities meeting the paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	findAll<T>(structureId: string, pageable: Pageable): Promise<IterablePage<T>>;
+	findAll<T>(entityDefinitionId: string, pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Returns a single {@link Page} of entities meeting the paging restriction provided in the {@link Pageable} object.
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param pageable the page settings to be used
 	*/
-	findAllSinglePage<T>(structureId: string, pageable: Pageable): Promise<Page<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, pageable: Pageable): Promise<Page<T>>;
 	/**
 	* Retrieves an entity by its id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} with the entity with the given id or {@link Promise} emitting null if none found
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	findById<T>(structureId: string, id: string): Promise<T>;
+	findById<T>(entityDefinitionId: string, id: string): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param ids      must not be {@literal null}
 	* @return Promise emitting the entities with the given ids or Promise emitting null if none found
 	* @throws Error in case the given {@literal ids} is {@literal null}
 	*/
-	findByIds<T>(structureId: string, ids: string[]): Promise<T[]>;
+	findByIds<T>(entityDefinitionId: string, ids: string[]): Promise<T[]>;
 	/**
 	* Executes a named query.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @returns Promise with the result of the query
 	*/
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
 	/**
 	* Executes a named query and returns a Page of results.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @param pageable the page settings to be used
 	* @returns Promise with the result of the query
 	*/
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
 	* entity instance completely.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param entity      must not be {@literal null}
 	* @return {@link Promise} emitting the saved entity
 	* @throws IllegalArgumentException in case the given {@literal entity} is {@literal null}
 	*/
-	save<T>(structureId: string, entity: T): Promise<T>;
+	save<T>(entityDefinitionId: string, entity: T): Promise<T>;
 	/**
 	* Returns a {@link IterablePage} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	search<T>(structureId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
 	/**
 	* Returns a single {@link Page} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	searchSinglePage<T>(structureId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
 	/**
 	* This operation makes all the recent writes immediately available for search.
-	* @param structureId the id of the structure to sync the index for.
+	* @param entityDefinitionId the id of the structure to sync the index for.
 	* @return a Promise that resolves when the operation is complete
 	*/
-	syncIndex(structureId: string): Promise<void>;
+	syncIndex(entityDefinitionId: string): Promise<void>;
 	/**
 	* Updates a given entity. This will only override the fields that are present in the given entity.
 	* If any fields are not present in the given entity data, they will not be changed.
 	* If the entity does not exist, it will be created.
 	*
-	* @param structureId the id of the structure to update the entity for
+	* @param entityDefinitionId the id of the structure to update the entity for
 	* @param entity      must not be {@literal null}
 	* @return Promise emitting the saved entity
 	* @throws Error in case the given {@literal entity} is {@literal null}
 	*/
-	update<T>(structureId: string, entity: T): Promise<T>;
+	update<T>(entityDefinitionId: string, entity: T): Promise<T>;
 }
 declare class EntitiesRepository implements IEntitiesRepository {
 	protected serviceProxy: IServiceProxy;
 	constructor(kinotic: IKinotic);
-	bulkSave<T>(structureId: string, entities: T[]): Promise<void>;
-	bulkUpdate<T>(structureId: string, entities: T[]): Promise<void>;
-	count(structureId: string): Promise<number>;
-	countByQuery(structureId: string, query: string): Promise<number>;
-	deleteById(structureId: string, id: string): Promise<void>;
-	deleteByQuery(structureId: string, query: string): Promise<void>;
-	findAll<T>(structureId: string, pageable: Pageable): Promise<IterablePage<T>>;
-	findAllSinglePage<T>(structureId: string, pageable: Pageable): Promise<Page<T>>;
-	findById<T>(structureId: string, id: string): Promise<T>;
-	findByIds<T>(structureId: string, ids: string[]): Promise<T[]>;
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
-	namedQuerySinglePage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<Page<T>>;
-	save<T>(structureId: string, entity: T): Promise<T>;
-	search<T>(structureId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
-	searchSinglePage<T>(structureId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
-	syncIndex(structureId: string): Promise<void>;
-	update<T>(structureId: string, entity: T): Promise<T>;
+	bulkSave<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
+	bulkUpdate<T>(entityDefinitionId: string, entities: T[]): Promise<void>;
+	count(entityDefinitionId: string): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string): Promise<number>;
+	deleteById(entityDefinitionId: string, id: string): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string): Promise<void>;
+	findAll<T>(entityDefinitionId: string, pageable: Pageable): Promise<IterablePage<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, pageable: Pageable): Promise<Page<T>>;
+	findById<T>(entityDefinitionId: string, id: string): Promise<T | null>;
+	findByIds<T>(entityDefinitionId: string, ids: string[]): Promise<T[]>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<IterablePage<T>>;
+	namedQuerySinglePage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable): Promise<Page<T>>;
+	save<T>(entityDefinitionId: string, entity: T): Promise<T>;
+	search<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<IterablePage<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, pageable: Pageable): Promise<Page<T>>;
+	syncIndex(entityDefinitionId: string): Promise<void>;
+	update<T>(entityDefinitionId: string, entity: T): Promise<T>;
 }
 import { IKinotic as IKinotic2 } from "@kinotic-ai/core";
 import { IServiceProxy as IServiceProxy2, Page as Page2, Pageable as Pageable2, IterablePage as IterablePage2 } from "@kinotic-ai/core";
@@ -381,106 +381,106 @@ interface IAdminEntitiesRepository {
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @return {@link Promise} emitting the number of entities.
 	*/
-	count(structureId: string, tenantSelection: TenantSelection): Promise<number>;
+	count(entityDefinitionId: string, tenantSelection: TenantSelection): Promise<number>;
 	/**
 	* Returns the number of entities available for the given query.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query       the query used to limit result
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @return Promise    emitting the number of entities
 	*/
-	countByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} emitting when delete is complete
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	deleteById(structureId: string, id: TenantSpecificId): Promise<void>;
+	deleteById(entityDefinitionId: string, id: TenantSpecificId): Promise<void>;
 	/**
 	* Deletes the entity with the given id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param query      the query used to filter records to delete, must not be {@literal null}
 	* @param tenantSelection the list of tenants to use when deleting the entity records
 	* @return Promise signaling when operation has completed
 	* @throws Error in case the given {@literal query} is {@literal null}
 	*/
-	deleteByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
 	/**
 	* Returns a {@link IterablePage} of entities meeting the paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	findAll<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	findAll<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
 	/**
 	* Retrieves an entity by its id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param id          must not be {@literal null}
 	* @return {@link Promise} with the entity with the given id or {@link Promise} emitting null if none found
 	* @throws IllegalArgumentException in case the given {@literal id} is {@literal null}
 	*/
-	findById<T>(structureId: string, id: TenantSpecificId): Promise<T>;
+	findById<T>(entityDefinitionId: string, id: TenantSpecificId): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param ids      must not be {@literal null}
 	* @return Promise emitting the entities with the given ids or Promise emitting null if none found
 	* @throws Error in case the given {@literal ids} is {@literal null}
 	*/
-	findByIds<T>(structureId: string, ids: TenantSpecificId[]): Promise<T[]>;
+	findByIds<T>(entityDefinitionId: string, ids: TenantSpecificId[]): Promise<T[]>;
 	/**
 	* Executes a named query.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @returns Promise with the result of the query
 	*/
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
 	/**
 	* Executes a named query and returns a Page of results.
-	* @param structureId the id of the structure that this named query is defined for
+	* @param entityDefinitionId the id of the structure that this named query is defined for
 	* @param queryName the name of the function that defines the query
 	* @param parameters to pass to the query
 	* @param pageable the page settings to be used
 	* @returns Promise with the result of the query
 	*/
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
 	/**
 	* Returns a {@link IterablePage} of entities matching the search text and paging restriction provided in the {@link Pageable} object.
 	*
-	* @param structureId the id of the structure to save the entity for
+	* @param entityDefinitionId the id of the structure to save the entity for
 	* @param searchText  the text to search for entities for
 	* @param tenantSelection the list of tenants to use when retrieving the entity records
 	* @param pageable    the page settings to be used
 	* @return a page of entities
 	*/
-	search<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
 }
 declare class AdminEntitiesRepository implements IAdminEntitiesRepository {
 	protected serviceProxy: IServiceProxy2;
 	constructor(kinotic: IKinotic2);
-	count(structureId: string, tenantSelection: TenantSelection): Promise<number>;
-	countByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
-	deleteById(structureId: string, id: TenantSpecificId): Promise<void>;
-	deleteByQuery(structureId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
-	findAll<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
-	findAllSinglePage<T>(structureId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
-	findById<T>(structureId: string, id: TenantSpecificId): Promise<T>;
-	findByIds<T>(structureId: string, ids: TenantSpecificId[]): Promise<T[]>;
-	namedQuery<T>(structureId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
-	namedQueryPage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
-	namedQuerySinglePage<T>(structureId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<Page2<T>>;
-	search<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
-	searchSinglePage<T>(structureId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
+	count(entityDefinitionId: string, tenantSelection: TenantSelection): Promise<number>;
+	countByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<number>;
+	deleteById(entityDefinitionId: string, id: TenantSpecificId): Promise<void>;
+	deleteByQuery(entityDefinitionId: string, query: string, tenantSelection: TenantSelection): Promise<void>;
+	findAll<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	findAllSinglePage<T>(entityDefinitionId: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
+	findById<T>(entityDefinitionId: string, id: TenantSpecificId): Promise<T>;
+	findByIds<T>(entityDefinitionId: string, ids: TenantSpecificId[]): Promise<T[]>;
+	namedQuery<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[]): Promise<T>;
+	namedQueryPage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<IterablePage2<T>>;
+	namedQuerySinglePage<T>(entityDefinitionId: string, queryName: string, parameters: QueryParameter[], pageable: Pageable2): Promise<Page2<T>>;
+	search<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<IterablePage2<T>>;
+	searchSinglePage<T>(entityDefinitionId: string, searchText: string, tenantSelection: TenantSelection, pageable: Pageable2): Promise<Page2<T>>;
 }
 import { Pageable as Pageable3, IterablePage as IterablePage3 } from "@kinotic-ai/core";
 /**
@@ -556,7 +556,7 @@ interface IEntityRepository<T> {
 	* @return Promise emitting the entity with the given id or Promise emitting null if none found
 	* @throws Error in case the given {@literal id} is {@literal null}
 	*/
-	findById(id: string): Promise<T>;
+	findById(id: string): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
@@ -622,7 +622,7 @@ declare class EntityRepository<T> implements IEntityRepository<T> {
 	entityName: string;
 	entityId: string;
 	private readonly entitiesRepository;
-	constructor(structureApplicationId: string, structureName: string, entitiesRepository?: IEntitiesRepository);
+	constructor(entityApplicationId: string, entityName: string, entitiesRepository?: IEntitiesRepository);
 	bulkSave(entities: T[]): Promise<void>;
 	bulkUpdate(entities: T[]): Promise<void>;
 	count(): Promise<number>;
@@ -630,7 +630,7 @@ declare class EntityRepository<T> implements IEntityRepository<T> {
 	deleteById(id: string): Promise<void>;
 	deleteByQuery(query: string): Promise<void>;
 	findAll(pageable: Pageable3): Promise<IterablePage3<T>>;
-	findById(id: string): Promise<T>;
+	findById(id: string): Promise<T | null>;
 	findByIds(ids: string[]): Promise<T[]>;
 	namedQuery<U>(queryName: string, queryParameters: QueryParameter[]): Promise<U>;
 	namedQueryPage<U>(queryName: string, queryParameters: QueryParameter[], pageable: Pageable3): Promise<IterablePage3<U>>;
@@ -707,7 +707,7 @@ interface IAdminEntityRepository<T> {
 	* @return Promise emitting the entity with the given id or Promise emitting null if none found
 	* @throws Error in case the given {@literal id} is {@literal null}
 	*/
-	findById(id: TenantSpecificId): Promise<T>;
+	findById(id: TenantSpecificId): Promise<T | null>;
 	/**
 	* Retrieves a list of entities by their id.
 	*
@@ -750,7 +750,7 @@ declare class AdminEntityRepository<T> implements IAdminEntityRepository<T> {
 	entityName: string;
 	entityId: string;
 	private readonly adminEntitiesRepository;
-	constructor(structureApplicationId: string, structureName: string, adminEntitiesRepository?: IAdminEntitiesRepository);
+	constructor(entityApplicationId: string, entityName: string, adminEntitiesRepository?: IAdminEntitiesRepository);
 	count(tenantSelection: TenantSelection): Promise<number>;
 	countByQuery(query: string, tenantSelection: TenantSelection): Promise<number>;
 	deleteById(id: TenantSpecificId): Promise<void>;

package/dist/index.js CHANGED Viewed

@@ -186,62 +186,62 @@ class EntitiesRepository {
   constructor(kinotic) {
     this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.JsonEntitiesRepository");
   }
-  bulkSave(structureId, entities) {
-    return this.serviceProxy.invoke("bulkSave", [structureId, entities]);
+  bulkSave(entityDefinitionId, entities) {
+    return this.serviceProxy.invoke("bulkSave", [entityDefinitionId, entities]);
   }
-  bulkUpdate(structureId, entities) {
-    return this.serviceProxy.invoke("bulkUpdate", [structureId, entities]);
+  bulkUpdate(entityDefinitionId, entities) {
+    return this.serviceProxy.invoke("bulkUpdate", [entityDefinitionId, entities]);
   }
-  count(structureId) {
-    return this.serviceProxy.invoke("count", [structureId]);
+  count(entityDefinitionId) {
+    return this.serviceProxy.invoke("count", [entityDefinitionId]);
   }
-  countByQuery(structureId, query) {
-    return this.serviceProxy.invoke("countByQuery", [structureId, query]);
+  countByQuery(entityDefinitionId, query) {
+    return this.serviceProxy.invoke("countByQuery", [entityDefinitionId, query]);
   }
-  deleteById(structureId, id) {
-    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  deleteById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("deleteById", [entityDefinitionId, id]);
   }
-  deleteByQuery(structureId, query) {
-    return this.serviceProxy.invoke("deleteByQuery", [structureId, query]);
+  deleteByQuery(entityDefinitionId, query) {
+    return this.serviceProxy.invoke("deleteByQuery", [entityDefinitionId, query]);
   }
-  async findAll(structureId, pageable) {
-    const page = await this.findAllSinglePage(structureId, pageable);
-    return new FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(structureId, pageable2));
+  async findAll(entityDefinitionId, pageable) {
+    const page = await this.findAllSinglePage(entityDefinitionId, pageable);
+    return new FunctionalIterablePage(pageable, page, (pageable2) => this.findAllSinglePage(entityDefinitionId, pageable2));
   }
-  async findAllSinglePage(structureId, pageable) {
-    return this.serviceProxy.invoke("findAll", [structureId, pageable]);
+  async findAllSinglePage(entityDefinitionId, pageable) {
+    return this.serviceProxy.invoke("findAll", [entityDefinitionId, pageable]);
   }
-  findById(structureId, id) {
-    return this.serviceProxy.invoke("findById", [structureId, id]);
+  findById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("findById", [entityDefinitionId, id]);
   }
-  findByIds(structureId, ids) {
-    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  findByIds(entityDefinitionId, ids) {
+    return this.serviceProxy.invoke("findByIds", [entityDefinitionId, ids]);
   }
-  namedQuery(structureId, queryName, parameters) {
-    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  namedQuery(entityDefinitionId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [entityDefinitionId, queryName, parameters]);
   }
-  async namedQueryPage(structureId, queryName, parameters, pageable) {
-    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
-    return new FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  async namedQueryPage(entityDefinitionId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable);
+    return new FunctionalIterablePage(pageable, page, (pageable2) => this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable2));
   }
-  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
-    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [entityDefinitionId, queryName, parameters, pageable]);
   }
-  save(structureId, entity) {
-    return this.serviceProxy.invoke("save", [structureId, entity]);
+  save(entityDefinitionId, entity) {
+    return this.serviceProxy.invoke("save", [entityDefinitionId, entity]);
   }
-  async search(structureId, searchText, pageable) {
-    const page = await this.searchSinglePage(structureId, searchText, pageable);
-    return new FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, pageable2));
+  async search(entityDefinitionId, searchText, pageable) {
+    const page = await this.searchSinglePage(entityDefinitionId, searchText, pageable);
+    return new FunctionalIterablePage(pageable, page, (pageable2) => this.searchSinglePage(entityDefinitionId, searchText, pageable2));
   }
-  async searchSinglePage(structureId, searchText, pageable) {
-    return this.serviceProxy.invoke("search", [structureId, searchText, pageable]);
+  async searchSinglePage(entityDefinitionId, searchText, pageable) {
+    return this.serviceProxy.invoke("search", [entityDefinitionId, searchText, pageable]);
   }
-  async syncIndex(structureId) {
-    return this.serviceProxy.invoke("syncIndex", [structureId]);
+  async syncIndex(entityDefinitionId) {
+    return this.serviceProxy.invoke("syncIndex", [entityDefinitionId]);
   }
-  update(structureId, entity) {
-    return this.serviceProxy.invoke("update", [structureId, entity]);
+  update(entityDefinitionId, entity) {
+    return this.serviceProxy.invoke("update", [entityDefinitionId, entity]);
   }
 }
 // packages/persistence/src/api/IAdminEntitiesRepository.ts
@@ -254,47 +254,47 @@ class AdminEntitiesRepository {
   constructor(kinotic) {
     this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.AdminJsonEntitiesRepository");
   }
-  count(structureId, tenantSelection) {
-    return this.serviceProxy.invoke("count", [structureId, tenantSelection]);
+  count(entityDefinitionId, tenantSelection) {
+    return this.serviceProxy.invoke("count", [entityDefinitionId, tenantSelection]);
   }
-  countByQuery(structureId, query, tenantSelection) {
-    return this.serviceProxy.invoke("countByQuery", [structureId, query, tenantSelection]);
+  countByQuery(entityDefinitionId, query, tenantSelection) {
+    return this.serviceProxy.invoke("countByQuery", [entityDefinitionId, query, tenantSelection]);
   }
-  deleteById(structureId, id) {
-    return this.serviceProxy.invoke("deleteById", [structureId, id]);
+  deleteById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("deleteById", [entityDefinitionId, id]);
   }
-  deleteByQuery(structureId, query, tenantSelection) {
-    return this.serviceProxy.invoke("deleteByQuery", [structureId, query, tenantSelection]);
+  deleteByQuery(entityDefinitionId, query, tenantSelection) {
+    return this.serviceProxy.invoke("deleteByQuery", [entityDefinitionId, query, tenantSelection]);
   }
-  async findAll(structureId, tenantSelection, pageable) {
-    const page = await this.findAllSinglePage(structureId, tenantSelection, pageable);
-    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.findAllSinglePage(structureId, tenantSelection, pageable2));
+  async findAll(entityDefinitionId, tenantSelection, pageable) {
+    const page = await this.findAllSinglePage(entityDefinitionId, tenantSelection, pageable);
+    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.findAllSinglePage(entityDefinitionId, tenantSelection, pageable2));
   }
-  async findAllSinglePage(structureId, tenantSelection, pageable) {
-    return this.serviceProxy.invoke("findAll", [structureId, tenantSelection, pageable]);
+  async findAllSinglePage(entityDefinitionId, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("findAll", [entityDefinitionId, tenantSelection, pageable]);
   }
-  findById(structureId, id) {
-    return this.serviceProxy.invoke("findById", [structureId, id]);
+  findById(entityDefinitionId, id) {
+    return this.serviceProxy.invoke("findById", [entityDefinitionId, id]);
   }
-  findByIds(structureId, ids) {
-    return this.serviceProxy.invoke("findByIds", [structureId, ids]);
+  findByIds(entityDefinitionId, ids) {
+    return this.serviceProxy.invoke("findByIds", [entityDefinitionId, ids]);
   }
-  namedQuery(structureId, queryName, parameters) {
-    return this.serviceProxy.invoke("namedQuery", [structureId, queryName, parameters]);
+  namedQuery(entityDefinitionId, queryName, parameters) {
+    return this.serviceProxy.invoke("namedQuery", [entityDefinitionId, queryName, parameters]);
   }
-  async namedQueryPage(structureId, queryName, parameters, pageable) {
-    const page = await this.namedQuerySinglePage(structureId, queryName, parameters, pageable);
-    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.namedQuerySinglePage(structureId, queryName, parameters, pageable2));
+  async namedQueryPage(entityDefinitionId, queryName, parameters, pageable) {
+    const page = await this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable);
+    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable2));
   }
-  namedQuerySinglePage(structureId, queryName, parameters, pageable) {
-    return this.serviceProxy.invoke("namedQueryPage", [structureId, queryName, parameters, pageable]);
+  namedQuerySinglePage(entityDefinitionId, queryName, parameters, pageable) {
+    return this.serviceProxy.invoke("namedQueryPage", [entityDefinitionId, queryName, parameters, pageable]);
   }
-  async search(structureId, searchText, tenantSelection, pageable) {
-    const page = await this.searchSinglePage(structureId, searchText, tenantSelection, pageable);
-    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.searchSinglePage(structureId, searchText, tenantSelection, pageable2));
+  async search(entityDefinitionId, searchText, tenantSelection, pageable) {
+    const page = await this.searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable);
+    return new FunctionalIterablePage2(pageable, page, (pageable2) => this.searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable2));
   }
-  async searchSinglePage(structureId, searchText, tenantSelection, pageable) {
-    return this.serviceProxy.invoke("search", [structureId, searchText, tenantSelection, pageable]);
+  async searchSinglePage(entityDefinitionId, searchText, tenantSelection, pageable) {
+    return this.serviceProxy.invoke("search", [entityDefinitionId, searchText, tenantSelection, pageable]);
   }
 }
 // packages/persistence/src/api/IEntityRepository.ts
@@ -304,10 +304,10 @@ class EntityRepository {
   entityName;
   entityId;
   entitiesRepository;
-  constructor(structureApplicationId, structureName, entitiesRepository) {
-    this.entityApplicationId = structureApplicationId;
-    this.entityName = structureName;
-    this.entityId = (structureApplicationId + "." + structureName).toLowerCase();
+  constructor(entityApplicationId, entityName, entitiesRepository) {
+    this.entityApplicationId = entityApplicationId;
+    this.entityName = entityName;
+    this.entityId = (entityApplicationId + "." + entityName).toLowerCase();
     this.entitiesRepository = entitiesRepository ?? new EntitiesRepository(Kinotic);
   }
   async bulkSave(entities) {
@@ -373,10 +373,10 @@ class AdminEntityRepository {
   entityName;
   entityId;
   adminEntitiesRepository;
-  constructor(structureApplicationId, structureName, adminEntitiesRepository) {
-    this.entityApplicationId = structureApplicationId;
-    this.entityName = structureName;
-    this.entityId = (structureApplicationId + "." + structureName).toLowerCase();
+  constructor(entityApplicationId, entityName, adminEntitiesRepository) {
+    this.entityApplicationId = entityApplicationId;
+    this.entityName = entityName;
+    this.entityId = (entityApplicationId + "." + entityName).toLowerCase();
     this.adminEntitiesRepository = adminEntitiesRepository ?? new AdminEntitiesRepository(Kinotic2);
   }
   count(tenantSelection) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@kinotic-ai/persistence",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "files": [
     "dist"
@@ -41,7 +41,7 @@
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@kinotic-ai/core": "1.1.1",
+    "@kinotic-ai/core": "1.2.1",
     "@types/node": "^25.3.2",
     "@vitest/coverage-v8": "^4.0.18",
     "@vitest/runner": "^4.0.18",