@icure/cardinal-sdk 2.1.1 → 2.1.2

package/api/FormBasicApi.d.mts

@@ -5,17 +5,120 @@ import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs'
 import { FormBasicInGroupApi } from './FormBasicInGroupApi.mjs';
 export interface FormBasicApi {
     inGroup: FormBasicInGroupApi;
+    /**
+     *
+     *  Get the ids of all forms matching the provided filter.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [matchFormsBySorted] instead.
+     *
+     *  @param filter a form filter
+     *  @return a list of form ids
+     */
     matchFormsBy(filter: BaseFilterOptions<Form>): Promise<Array<string>>;
+    /**
+     *
+     *  Get the ids of all forms matching the provided filter.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [matchFormsBy].
+     *
+     *  @param filter a form filter
+     *  @return a list of form ids
+     */
     matchFormsBySorted(filter: BaseSortableFilterOptions<Form>): Promise<Array<string>>;
+    /**
+     *
+     *  Get an iterator that iterates through all forms matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterFormsBySorted] instead.
+     *
+     *  @param filter a form filter
+     *  @return an iterator that iterates over all forms matching the provided filter.
+     */
     filterFormsBy(filter: BaseFilterOptions<Form>): Promise<PaginatedListIterator<EncryptedForm>>;
+    /**
+     *
+     *  Get an iterator that iterates through all forms matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterFormsBy].
+     *
+     *  @param filter a form filter
+     *  @return an iterator that iterates over all forms matching the provided filter.
+     */
     filterFormsBySorted(filter: BaseSortableFilterOptions<Form>): Promise<PaginatedListIterator<EncryptedForm>>;
+    /**
+     *
+     *  Deletes a form. If you don't have write access to the form the method will fail.
+     *  @param entityId id of the form.
+     *  @param rev the latest known rev of the form to delete
+     *  @return the id and revision of the deleted form.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     deleteFormById(entityId: string, rev: string): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many forms. Ids that do not correspond to an entity, or that correspond to an entity for which
+     *  you don't have write access will be ignored.
+     *  @param entityIds ids and revisions of the forms to delete.
+     *  @return the id and revision of the deleted forms. If some entities could not be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     deleteFormsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a form.
+     *  @param id id of the form to purge
+     *  @param rev latest revision of the form
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     purgeFormById(id: string, rev: string): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many forms.
+     *  @param entityIds ids and revisions of the forms to delete
+     *  @return the id and revision of the deleted forms. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeFormsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Deletes a form. If you don't have write access to the form the method will fail.
+     *  @param form the form to delete
+     *  @return the id and revision of the deleted form.
+     *  @throws RevisionConflictException if the provided form doesn't match the latest known revision
+     */
     deleteForm(form: Form): Promise<StoredDocumentIdentifier>;
+    /**
+     *
+     *  Deletes many forms. Ignores form for which you don't have write access or that don't match the latest revision.
+     *  @param forms the forms to delete
+     *  @return the id and revision of the deleted forms. If some entities couldn't be deleted they will not be
+     *  included in this list.
+     */
     deleteForms(forms: Array<Form>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Permanently deletes a form.
+     *  @param form the form to purge.
+     *  @throws RevisionConflictException if the provided form doesn't match the latest known revision
+     */
     purgeForm(form: Form): Promise<void>;
+    /**
+     *
+     *  Permanently deletes many forms.
+     *  @param forms the forms to purge.
+     *  @return the id and revision of the deleted forms. If some entities couldn't be deleted (for example
+     *  because you had no write access to them) they will not be included in this list.
+     */
     purgeForms(forms: Array<Form>): Promise<Array<StoredDocumentIdentifier>>;
     getFormTemplate(formTemplateId: string, options?: {
         raw?: boolean | undefined;
@@ -37,17 +140,106 @@ export interface FormBasicApi {
     purgeFormTemplatesByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<StoredDocumentIdentifier>>;
     purgeFormTemplate(formTemplate: FormTemplate): Promise<void>;
     purgeFormTemplates(formTemplates: Array<FormTemplate>): Promise<Array<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  Sets the attachment to the form template.
+     */
     setTemplateAttachment(formTemplateId: string, payload: Int8Array): Promise<string>;
     matchFormTemplateBy(filter: BaseFilterOptions<FormTemplate>): Promise<Array<string>>;
+    /**
+     *
+     *  Create a new form. The provided form must have the encryption metadata initialized.
+     *  @param entity a form with initialized encryption metadata
+     *  @return the created form with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createForm(entity: EncryptedForm): Promise<EncryptedForm>;
+    /**
+     *
+     *  Create multiple forms. All the provided forms must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities forms with initialized encryption metadata
+     *  @return the created forms with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any form in the input was not initialized.
+     */
     createForms(entities: Array<EncryptedForm>): Promise<Array<EncryptedForm>>;
+    /**
+     *
+     *  Modifies a form. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity a form with update content
+     *  @return the form updated with the provided content and a new revision.
+     */
     modifyForm(entity: EncryptedForm): Promise<EncryptedForm>;
+    /**
+     *
+     *  Modifies multiple forms. Ignores all forms for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities forms with update content
+     *  @return the updated forms with a new revision.
+     */
     modifyForms(entities: Array<EncryptedForm>): Promise<Array<EncryptedForm>>;
+    /**
+     *
+     *  Restores a form that was marked as deleted.
+     *  @param id the id of the entity
+     *  @param rev the latest revision of the entity.
+     *  @return the restored entity.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     undeleteFormById(id: string, rev: string): Promise<EncryptedForm>;
+    /**
+     *
+     *  Restores a batch of formIds that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the formIds to restore.
+     *  @return the restored formIds. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteFormsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<EncryptedForm>>;
+    /**
+     *
+     *  Restores a form that was marked as deleted.
+     *  @param form the form to undelete
+     *  @return the restored form.
+     *  @throws RevisionConflictException if the provided form doesn't match the latest known revision
+     */
     undeleteForm(form: Form): Promise<EncryptedForm>;
+    /**
+     *
+     *  Restores a batch of forms that were marked as deleted.
+     *  @param forms the forms to restore.
+     *  @return the restored forms. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteForms(forms: Array<Form>): Promise<Array<EncryptedForm>>;
+    /**
+     *
+     *  Get a form by its id. You must have read access to the entity. Fails if the id does not correspond to any
+     *  entity, corresponds to an entity that is not a form, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId a form id.
+     *  @return the form with id [entityId].
+     */
     getForm(entityId: string): Promise<EncryptedForm | undefined>;
+    /**
+     *
+     *  Get multiple forms by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a form, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of forms ids
+     *  @return all forms that you can access with one of the provided ids.
+     */
     getForms(entityIds: Array<string>): Promise<Array<EncryptedForm>>;
+    /**
+     *
+     *  Get the latest form according to the [Form.created] field with the provided [Form.uniqueId].
+     *  If there are multiple forms with the provided unique id that have the same value for created (which also
+     *  matches the latest) the behaviour of this method is undefined. If you think this situation may happen in your
+     *  application you should not use this method and instead use filters to get all forms with the provided id.
+     *  Flavoured method.
+     *  @param uniqueId a form unique id
+     *  @return the latest form with the provided unique id.
+     */
     getLatestFormByUniqueId(uniqueId: string): Promise<EncryptedForm>;
 }

package/api/FormBasicInGroupApi.d.mts

@@ -4,17 +4,65 @@ import { FormTemplate } from '../model/FormTemplate.mjs';
 import { GroupScoped } from '../model/GroupScoped.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 export interface FormBasicInGroupApi {
+    /**
+     *
+     *  In-group version of [FormBasicApi.matchFormsBy]
+     */
     matchFormsBy(groupId: string, filter: BaseFilterOptions<Form>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [FormBasicApi.matchFormsBySorted]
+     */
     matchFormsBySorted(groupId: string, filter: BaseSortableFilterOptions<Form>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [FormBasicApi.filterFormsBy]
+     */
     filterFormsBy(groupId: string, filter: BaseFilterOptions<Form>): Promise<PaginatedListIterator<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicApi.filterFormsBySorted]
+     */
     filterFormsBySorted(groupId: string, filter: BaseSortableFilterOptions<Form>): Promise<PaginatedListIterator<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.deleteFormById]
+     */
     deleteFormById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.deleteFormsByIds]
+     */
     deleteFormsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.purgeFormById]
+     */
     purgeFormById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<void>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.purgeFormsByIds]
+     */
     purgeFormsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.deleteForm]
+     */
     deleteForm(form: GroupScoped<Form>): Promise<GroupScoped<StoredDocumentIdentifier>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.deleteForms]
+     */
     deleteForms(forms: Array<GroupScoped<Form>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.purgeForm]
+     */
     purgeForm(form: GroupScoped<Form>): Promise<void>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavourlessApi.purgeForms]
+     */
     purgeForms(forms: Array<GroupScoped<Form>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
     createFormTemplate(formTemplate: GroupScoped<FormTemplate>): Promise<GroupScoped<FormTemplate>>;
     createFormTemplates(formTemplates: Array<GroupScoped<FormTemplate>>): Promise<Array<GroupScoped<FormTemplate>>>;
@@ -35,14 +83,54 @@ export interface FormBasicInGroupApi {
     purgeFormTemplate(formTemplate: GroupScoped<FormTemplate>): Promise<void>;
     purgeFormTemplates(formTemplates: Array<GroupScoped<FormTemplate>>): Promise<Array<GroupScoped<StoredDocumentIdentifier>>>;
     matchFormTemplateBy(groupId: string, filter: BaseFilterOptions<FormTemplate>): Promise<Array<string>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.createForm].
+     */
     createForm(entity: GroupScoped<EncryptedForm>): Promise<GroupScoped<EncryptedForm>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.createForms].
+     */
     createForms(entities: Array<GroupScoped<EncryptedForm>>): Promise<Array<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteFormById]
+     */
     undeleteFormById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<EncryptedForm>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteFormsByIds]
+     */
     undeleteFormsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteForm]
+     */
     undeleteForm(form: GroupScoped<Form>): Promise<GroupScoped<EncryptedForm>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteForms]
+     */
     undeleteForms(forms: Array<GroupScoped<EncryptedForm>>): Promise<Array<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.modifyForm]
+     */
     modifyForm(entity: GroupScoped<EncryptedForm>): Promise<GroupScoped<EncryptedForm>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.modifyForms]
+     */
     modifyForms(entities: Array<GroupScoped<EncryptedForm>>): Promise<Array<GroupScoped<EncryptedForm>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.getForm]
+     */
     getForm(groupId: string, entityId: string): Promise<GroupScoped<EncryptedForm> | undefined>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.getForms]
+     */
     getForms(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<EncryptedForm>>>;
 }

package/api/FormFlavouredApi.d.mts

@@ -3,23 +3,157 @@ import { FormShareOptions } from '../crypto/entities/FormShareOptions.mjs';
 import { Form } from '../model/Form.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 export interface FormFlavouredApi<E extends Form> {
+    /**
+     *
+     *  Share a form with another data owner. The form must already exist in the database for this method to
+     *  succeed. If you want to share the form before creation you should instead pass provide the delegates in
+     *  the initialize encryption metadata method.
+     *  Note: this method only updates the security metadata. If the input entity has unsaved changes they may be lost.
+     *  @param delegateId the owner that will gain access to the form
+     *  @param form the form to share with [delegateId]
+     *  @param options specifies how the form will be shared. By default, all data available to the current user
+     *  will be shared, and the delegate will have the same permissions as the current user on the form. Refer
+     *  to the documentation of [FormShareOptions] for more information.
+     *  @return the updated form if the sharing was successful, or details on the errors if the sharing failed.
+     */
     shareWith(delegateId: string, form: E, options?: {
         options?: FormShareOptions | undefined;
     }): Promise<E>;
+    /**
+     *
+     *  Share a form with multiple data owners. The form must already exist in the database for this method to
+     *  succeed. If you want to share the form before creation you should instead pass provide the delegates in
+     *  the initialize encryption metadata method.
+     *  Note: this method only updates the security metadata. If the input entity has unsaved changes they may be lost.
+     *  Throws an exception if the operation fails.
+     *  @param form the form to share
+     *  @param delegates specify the data owners which will gain access to the entity and the options for sharing with
+     *  each of them.
+     *  @return the updated form.
+     */
     shareWithMany(form: E, delegates: {
         [key: string]: FormShareOptions;
     }): Promise<E>;
+    /**
+     *
+     *  Get an iterator that iterates through all forms matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method does not guarantee that the returned data will be ordered when using sortable filter options.
+     *  Even if the data obtained from an invocation of the method appears to be ordered, any changes to the stored data,
+     *  or to the internal iCure implementations, may cause future invocations to return unordered data.
+     *  If you need ordered data use [filterFormsBySorted] instead.
+     *
+     *  @param filter a form filter
+     *  @return an iterator that iterates over all forms matching the provided filter.
+     */
     filterFormsBy(filter: FilterOptions<Form>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Get an iterator that iterates through all forms matching the provided filter, executing multiple requests to
+     *  the api if needed.
+     *
+     *  This method guarantees that the returned data will be ordered using the rules specified by the provided filter,
+     *  but the operation may take longer than [filterFormsBy].
+     *
+     *  @param filter a form filter
+     *  @return an iterator that iterates over all forms matching the provided filter.
+     */
     filterFormsBySorted(filter: SortableFilterOptions<Form>): Promise<PaginatedListIterator<E>>;
+    /**
+     *
+     *  Create a new form. The provided form must have the encryption metadata initialized.
+     *  @param entity a form with initialized encryption metadata
+     *  @return the created form with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of the input was not initialized.
+     */
     createForm(entity: E): Promise<E>;
+    /**
+     *
+     *  Create multiple forms. All the provided forms must have the encryption metadata initialized, otherwise
+     *  this method fails without doing anything.
+     *  @param entities forms with initialized encryption metadata
+     *  @return the created forms with updated revision.
+     *  @throws IllegalArgumentException if the encryption metadata of any form in the input was not initialized.
+     */
     createForms(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Modifies a form. You need to have write access to the entity.
+     *  Flavoured method.
+     *  @param entity a form with update content
+     *  @return the form updated with the provided content and a new revision.
+     */
     modifyForm(entity: E): Promise<E>;
+    /**
+     *
+     *  Modifies multiple forms. Ignores all forms for which you don't have write access.
+     *  Flavoured method.
+     *  @param entities forms with update content
+     *  @return the updated forms with a new revision.
+     */
     modifyForms(entities: Array<E>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a form that was marked as deleted.
+     *  @param id the id of the entity
+     *  @param rev the latest revision of the entity.
+     *  @return the restored entity.
+     *  @throws RevisionConflictException if the provided revision doesn't match the latest known revision
+     */
     undeleteFormById(id: string, rev: string): Promise<E>;
+    /**
+     *
+     *  Restores a batch of formIds that were marked as deleted.
+     *  @param entityIds the ids and the revisions of the formIds to restore.
+     *  @return the restored formIds. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteFormsByIds(entityIds: Array<StoredDocumentIdentifier>): Promise<Array<E>>;
+    /**
+     *
+     *  Restores a form that was marked as deleted.
+     *  @param form the form to undelete
+     *  @return the restored form.
+     *  @throws RevisionConflictException if the provided form doesn't match the latest known revision
+     */
     undeleteForm(form: Form): Promise<E>;
+    /**
+     *
+     *  Restores a batch of forms that were marked as deleted.
+     *  @param forms the forms to restore.
+     *  @return the restored forms. If some entities couldn't be restored (because the user does not have access or the revision is not
+     *  up-to-date), then those entities will not be restored and will not appear in this list.
+     */
     undeleteForms(forms: Array<Form>): Promise<Array<E>>;
+    /**
+     *
+     *  Get a form by its id. You must have read access to the entity. Fails if the id does not correspond to any
+     *  entity, corresponds to an entity that is not a form, or corresponds to an entity for which you don't have
+     *  read access.
+     *  Flavoured method.
+     *  @param entityId a form id.
+     *  @return the form with id [entityId].
+     */
     getForm(entityId: string): Promise<E | undefined>;
+    /**
+     *
+     *  Get multiple forms by their ids. Ignores all ids that do not correspond to an entity, correspond to
+     *  an entity that is not a form, or correspond to an entity for which you don't have read access.
+     *  Flavoured method.
+     *  @param entityIds a list of forms ids
+     *  @return all forms that you can access with one of the provided ids.
+     */
     getForms(entityIds: Array<string>): Promise<Array<E>>;
+    /**
+     *
+     *  Get the latest form according to the [Form.created] field with the provided [Form.uniqueId].
+     *  If there are multiple forms with the provided unique id that have the same value for created (which also
+     *  matches the latest) the behaviour of this method is undefined. If you think this situation may happen in your
+     *  application you should not use this method and instead use filters to get all forms with the provided id.
+     *  Flavoured method.
+     *  @param uniqueId a form unique id
+     *  @return the latest form with the provided unique id.
+     */
     getLatestFormByUniqueId(uniqueId: string): Promise<E>;
 }

package/api/FormFlavouredInGroupApi.d.mts

@@ -6,23 +6,79 @@ import { GroupScoped } from '../model/GroupScoped.mjs';
 import { StoredDocumentIdentifier } from '../model/StoredDocumentIdentifier.mjs';
 import { ArrayWithUniqueKeys } from '../utils/ArrayWithUniqueKeys.mjs';
 export interface FormFlavouredInGroupApi<E extends Form> {
+    /**
+     *
+     *  In-group version of [FormFlavouredApi.shareWith]
+     */
     shareWith(delegate: EntityReferenceInGroup, form: GroupScoped<E>, options?: {
         options?: FormShareOptions | undefined;
     }): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormFlavouredApi.shareWithMany]
+     */
     shareWithMany(form: GroupScoped<E>, delegates: ArrayWithUniqueKeys<{
         delegate: EntityReferenceInGroup;
         shareOptions: FormShareOptions;
     }, 'delegate'>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormFlavouredApi.filterFormsBy]
+     */
     filterFormsBy(groupId: string, filter: FilterOptions<Form>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormFlavouredApi.filterFormsBySorted]
+     */
     filterFormsBySorted(groupId: string, filter: SortableFilterOptions<Form>): Promise<PaginatedListIterator<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.createForm].
+     */
     createForm(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.createForms].
+     */
     createForms(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteFormById]
+     */
     undeleteFormById(entityId: GroupScoped<StoredDocumentIdentifier>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteFormsByIds]
+     */
     undeleteFormsByIds(entityIds: Array<GroupScoped<StoredDocumentIdentifier>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteForm]
+     */
     undeleteForm(form: GroupScoped<Form>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.undeleteForms]
+     */
     undeleteForms(forms: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.modifyForm]
+     */
     modifyForm(entity: GroupScoped<E>): Promise<GroupScoped<E>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.modifyForms]
+     */
     modifyForms(entities: Array<GroupScoped<E>>): Promise<Array<GroupScoped<E>>>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.getForm]
+     */
     getForm(groupId: string, entityId: string): Promise<GroupScoped<E> | undefined>;
+    /**
+     *
+     *  In-group version of [FormBasicFlavouredApi.getForms]
+     */
     getForms(groupId: string, entityIds: Array<string>): Promise<Array<GroupScoped<E>>>;
 }