@icure/cardinal-sdk 2.10.2 → 2.11.0

package/api/AccessLogApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { AccessLogDelegateOptions } from '../crypto/entities/AccessLogDelegateOptions.mjs';
 import { AccessLogShareOptions } from '../crypto/entities/AccessLogShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { AccessLog, DecryptedAccessLog, EncryptedAccessLog } from '../model/AccessLog.mjs';
@@ -27,7 +28,8 @@ export interface AccessLogApi {
      *  @return an access log with initialized encryption metadata.
      *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
      */
-    withEncryptionMetadata(base: DecryptedAccessLog | undefined, patient: Patient, options?: {
+    withEncryptionMetadata(base: DecryptedAccessLog | undefined, options?: {
+        patient?: Patient | undefined;
         user?: User | undefined;
         delegates?: {
             [key: string]: AccessLevel;
@@ -35,6 +37,29 @@ export interface AccessLogApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedAccessLog>;
+    /**
+     *
+     *  Creates a new access log with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base an access log with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the access log.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new access log
+     *  @return an access log with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedAccessLog | undefined, delegates: {
+        [key: string]: AccessLogDelegateOptions;
+    }, options?: {
+        patient?: Patient | undefined;
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedAccessLog>;
     /**
      *
      *  Attempts to extract the encryption keys of an access log. If the user does not have access to any encryption key

package/api/AccessLogInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { AccessLogDelegateOptions } from '../crypto/entities/AccessLogDelegateOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { AccessLog, DecryptedAccessLog, EncryptedAccessLog } from '../model/AccessLog.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -17,7 +18,8 @@ export interface AccessLogInGroupApi {
      *
      *  In-group version of [AccessLogApi.withEncryptionMetadata]
      */
-    withEncryptionMetadata(entityGroupId: string, base: DecryptedAccessLog | undefined, patient: GroupScoped<Patient>, options?: {
+    withEncryptionMetadata(entityGroupId: string, base: DecryptedAccessLog | undefined, options?: {
+        patient?: GroupScoped<Patient> | undefined;
         user?: User | undefined;
         delegates?: ArrayWithUniqueKeys<{
             delegate: EntityReferenceInGroup;
@@ -26,6 +28,19 @@ export interface AccessLogInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedAccessLog>>;
+    /**
+     *
+     *  In-group version of [AccessLogApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedAccessLog | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: AccessLogDelegateOptions;
+    }, 'delegate'>, options?: {
+        patient?: GroupScoped<Patient> | undefined;
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedAccessLog>>;
     /**
      *
      *  In-group version of [AccessLogApi.getEncryptionKeysOf]

package/api/CalendarItemApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { CalendarItemDelegateOptions } from '../crypto/entities/CalendarItemDelegateOptions.mjs';
 import { CalendarItemShareOptions } from '../crypto/entities/CalendarItemShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { CalendarItem, DecryptedCalendarItem, EncryptedCalendarItem } from '../model/CalendarItem.mjs';
@@ -41,6 +42,30 @@ export interface CalendarItemApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedCalendarItem>;
+    /**
+     *
+     *  Creates a new calendar item entity with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  NOTE: this method doesn't send the entity to the backend, to store it you will need to pass the entity to the
+     *  [createCalendarItem] method.
+     *  @param base a calendar item with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the calendar item.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new calendar item
+     *  @return a calendar item with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedCalendarItem | undefined, patient: Patient | undefined, delegates: {
+        [key: string]: CalendarItemDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedCalendarItem>;
     /**
      *
      *  Attempts to extract the encryption keys of a calendar item. If the user does not have access to any encryption key

package/api/CalendarItemInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { CalendarItemDelegateOptions } from '../crypto/entities/CalendarItemDelegateOptions.mjs';
 import { CalendarItemShareOptions } from '../crypto/entities/CalendarItemShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { CalendarItem, DecryptedCalendarItem, EncryptedCalendarItem } from '../model/CalendarItem.mjs';
@@ -28,6 +29,17 @@ export interface CalendarItemInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedCalendarItem>>;
+    /**
+     *
+     *  In-group version of [CalendarItemApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedCalendarItem | undefined, patient: GroupScoped<Patient> | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: CalendarItemDelegateOptions;
+    }, 'delegate'>, user: User | undefined, options?: {
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedCalendarItem>>;
     /**
      *
      *  In-group version of [CalendarItemApi.getEncryptionKeysOf]

package/api/ContactApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ContactDelegateOptions } from '../crypto/entities/ContactDelegateOptions.mjs';
 import { ContactShareOptions } from '../crypto/entities/ContactShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { Contact, DecryptedContact, EncryptedContact } from '../model/Contact.mjs';
@@ -88,6 +89,28 @@ export interface ContactApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedContact>;
+    /**
+     *
+     *  Creates a new contact with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a contact with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the contact.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new contact
+     *  @return a contact with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedContact | undefined, patient: Patient, delegates: {
+        [key: string]: ContactDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedContact>;
     /**
      *
      *  Attempts to extract the encryption keys of a contact. If the user does not have access to any encryption key

package/api/ContactInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ContactDelegateOptions } from '../crypto/entities/ContactDelegateOptions.mjs';
 import { ContactShareOptions } from '../crypto/entities/ContactShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { Contact, DecryptedContact, EncryptedContact } from '../model/Contact.mjs';
@@ -28,6 +29,18 @@ export interface ContactInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedContact>>;
+    /**
+     *
+     *  In-group version of [ContactApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedContact | undefined, patient: GroupScoped<Patient> | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: ContactDelegateOptions;
+    }, 'delegate'>, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedContact>>;
     /**
      *
      *  In-group version of [ContactApi.getEncryptionKeysOf]

package/api/DocumentApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { DocumentDelegateOptions } from '../crypto/entities/DocumentDelegateOptions.mjs';
 import { DocumentShareOptions } from '../crypto/entities/DocumentShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { DecryptedDocument, Document, EncryptedDocument } from '../model/Document.mjs';
@@ -38,7 +39,29 @@ export interface DocumentApi {
     }): Promise<DecryptedDocument>;
     /**
      *
-     *  Creates a new document with initialized encryption metadata
+     *  Creates a new document with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a document with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param message the message linked to the document, if any.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [message] to use for the new document
+     *  @return a document with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegatesLinkedToMessage(base: DecryptedDocument | undefined, message: Message, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedDocument>;
+    /**
+     *
+     *  Creates a new document with initialized encryption metadata.
      *  @param base a document with initialized content and uninitialized encryption metadata. The result of this
      *  method takes the content from [base] if provided.
      *  @param patient the patient linked to the patient, if any.
@@ -57,6 +80,27 @@ export interface DocumentApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedDocument>;
+    /**
+     *
+     *  Creates a new document with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a document with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the patient, if any.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [Message] to use for the new document
+     *  @return a document with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegatesLinkedToPatient(base: DecryptedDocument | undefined, patient: Patient, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedDocument>;
     /**
      *
      *  Creates a new document with initialized encryption metadata
@@ -75,6 +119,25 @@ export interface DocumentApi {
         };
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedDocument>;
+    /**
+     *
+     *  Creates a new document with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a document with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @return a document with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegatesUnlinked(base: DecryptedDocument | undefined, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedDocument>;
     /**
      *
      *  Retrieves and tries to decrypt the main attachment of a document.

package/api/DocumentInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { DocumentDelegateOptions } from '../crypto/entities/DocumentDelegateOptions.mjs';
 import { DocumentShareOptions } from '../crypto/entities/DocumentShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { DecryptedDocument, Document, EncryptedDocument } from '../model/Document.mjs';
@@ -27,6 +28,17 @@ export interface DocumentInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<GroupScoped<DecryptedDocument>>;
+    /**
+     *
+     *  In-group version of [DocumentApi.withEncryptionMetadataAndDelegatesLinkedToMessage]
+     */
+    withEncryptionMetadataAndDelegatesLinkedToMessage(entityGroupId: string, base: DecryptedDocument | undefined, message: GroupScoped<Message>, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<GroupScoped<DecryptedDocument>>;
     /**
      *
      *  In-group version of [DocumentApi.withEncryptionMetadataLinkedToPatient]
@@ -39,6 +51,17 @@ export interface DocumentInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<GroupScoped<DecryptedDocument>>;
+    /**
+     *
+     *  In-group version of [DocumentApi.withEncryptionMetadataAndDelegatesLinkedToPatient]
+     */
+    withEncryptionMetadataAndDelegatesLinkedToPatient(entityGroupId: string, base: DecryptedDocument | undefined, patient: GroupScoped<Patient>, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<GroupScoped<DecryptedDocument>>;
     /**
      *
      *  In-group version of [DocumentApi.withEncryptionMetadataUnlinked]
@@ -50,6 +73,16 @@ export interface DocumentInGroupApi {
         };
         alternateRootDelegateId?: string | undefined;
     }): Promise<GroupScoped<DecryptedDocument>>;
+    /**
+     *
+     *  In-group version of [DocumentApi.withEncryptionMetadataAndDelegatesUnlinked]
+     */
+    withEncryptionMetadataAndDelegatesUnlinked(entityGroupId: string, base: DecryptedDocument | undefined, delegates: {
+        [key: string]: DocumentDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<GroupScoped<DecryptedDocument>>;
     /**
      *
      *  In-group version of [DocumentApi.getEncryptionKeysOf]

package/api/FormApi.d.mts

@@ -1,4 +1,5 @@
 import { BaseFilterOptions, FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { FormDelegateOptions } from '../crypto/entities/FormDelegateOptions.mjs';
 import { FormShareOptions } from '../crypto/entities/FormShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -17,7 +18,7 @@ export interface FormApi {
     inGroup: FormInGroupApi;
     /**
      *
-     *  Creates a new form with initialized encryption metadata
+     *  Creates a new form with initialized encryption metadata.
      *  @param base a form with initialized content and uninitialized encryption metadata. The result of this
      *  method takes the content from [base] if provided.
      *  @param patient the patient linked to the form.
@@ -36,12 +37,34 @@ export interface FormApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedForm>;
+    /**
+     *
+     *  Creates a new access log with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a form with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the form.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new form
+     *  @return a form with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedForm | undefined, patient: Patient, delegates: {
+        [key: string]: FormDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedForm>;
     /**
      *
      *  Attempts to extract the encryption keys of a form. If the user does not have access to any encryption key
      *  of the access log the method will return an empty set.
      *  Note: entities now have only one encryption key, but this method returns a set for compatibility with older
-     *  versions of iCure where this was not a guarantee.
+     *  versions of Cardinal where this was not a guarantee.
      *  @param form a form
      *  @return the encryption keys extracted from the provided form.
      */

package/api/FormInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { BaseFilterOptions, FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { FormDelegateOptions } from '../crypto/entities/FormDelegateOptions.mjs';
 import { FormShareOptions } from '../crypto/entities/FormShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -28,6 +29,18 @@ export interface FormInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedForm>>;
+    /**
+     *
+     *  In-group version of [FormApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedForm | undefined, patient: GroupScoped<Patient> | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: FormDelegateOptions;
+    }, 'delegate'>, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedForm>>;
     /**
      *
      *  In-group version of [FormApi.getEncryptionKeysOf]

package/api/HealthElementApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { HealthElementDelegateOptions } from '../crypto/entities/HealthElementDelegateOptions.mjs';
 import { HealthElementShareOptions } from '../crypto/entities/HealthElementShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -19,7 +20,7 @@ export interface HealthElementApi {
     inGroup: HealthElementInGroupApi;
     /**
      *
-     *  Creates a new health element with initialized encryption metadata
+     *  Creates a new health element with initialized encryption metadata.
      *  @param base a health element with initialized content and uninitialized encryption metadata. The result of this
      *  method takes the content from [base] if provided.
      *  @param patient the patient linked to the health element.
@@ -38,6 +39,28 @@ export interface HealthElementApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedHealthElement>;
+    /**
+     *
+     *  Creates a new access log with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a health element with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the health element.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new health element
+     *  @return a health element with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedHealthElement | undefined, patient: Patient, delegates: {
+        [key: string]: HealthElementDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedHealthElement>;
     /**
      *
      *  Attempts to extract the encryption keys of a health element. If the user does not have access to any encryption key

package/api/HealthElementInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { HealthElementDelegateOptions } from '../crypto/entities/HealthElementDelegateOptions.mjs';
 import { HealthElementShareOptions } from '../crypto/entities/HealthElementShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -27,6 +28,18 @@ export interface HealthElementInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedHealthElement>>;
+    /**
+     *
+     *  In-group version of [HealthElementApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedHealthElement | undefined, patient: GroupScoped<Patient>, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: HealthElementDelegateOptions;
+    }, 'delegate'>, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedHealthElement>>;
     /**
      *
      *  In-group version of [HealthElementApi.getEncryptionKeysOf]

package/api/InvoiceApi.d.mts

@@ -1,4 +1,5 @@
 import { PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
+import { InvoiceDelegateOptions } from '../crypto/entities/InvoiceDelegateOptions.mjs';
 import { InvoiceShareOptions } from '../crypto/entities/InvoiceShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -40,6 +41,28 @@ export interface InvoiceApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedInvoice>;
+    /**
+     *
+     *  Creates a new access log with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base an invoice with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the invoice.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new invoice
+     *  @return an invoice with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedInvoice | undefined, patient: Patient | undefined, delegates: {
+        [key: string]: InvoiceDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedInvoice>;
     /**
      *
      *  Attempts to extract the encryption keys of an invoice. If the user does not have access to any encryption key
@@ -187,7 +210,7 @@ export interface InvoiceApi {
     /**
      *
      *  Gives an approximation of the amount of times each tarification code ([Invoice.invoicingCodes] ->
-     *  [InvoicingCode.tarificationId]) is used in invoices where the current data owner is a direct delegate (does not
+     *  [InvoicingCode.pricingId]) is used in invoices where the current data owner is a direct delegate (does not
      *  count situations where the data owner has access to the service through delegations to a parent data owner).
      *  This number is not exact, and may be cached, so you should not use this method if you need precise values, but
      *  it can be useful if you want to give suggestions.

package/api/InvoiceBasicApi.d.mts

@@ -76,7 +76,7 @@ export interface InvoiceBasicApi {
     /**
      *
      *  Gives an approximation of the amount of times each tarification code ([Invoice.invoicingCodes] ->
-     *  [InvoicingCode.tarificationId]) is used in invoices where the current data owner is a direct delegate (does not
+     *  [InvoicingCode.pricingId]) is used in invoices where the current data owner is a direct delegate (does not
      *  count situations where the data owner has access to the service through delegations to a parent data owner).
      *  This number is not exact, and may be cached, so you should not use this method if you need precise values, but
      *  it can be useful if you want to give suggestions.

package/api/InvoiceInGroupApi.d.mts

@@ -1,3 +1,4 @@
+import { InvoiceDelegateOptions } from '../crypto/entities/InvoiceDelegateOptions.mjs';
 import { InvoiceShareOptions } from '../crypto/entities/InvoiceShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -26,6 +27,18 @@ export interface InvoiceInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedInvoice>>;
+    /**
+     *
+     *  In-group version of [InvoiceApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedInvoice | undefined, patient: GroupScoped<Patient> | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: InvoiceDelegateOptions;
+    }, 'delegate'>, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedInvoice>>;
     /**
      *
      *  In-group version of [InvoiceApi.getEncryptionKeysOf]

package/api/MessageApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { MessageDelegateOptions } from '../crypto/entities/MessageDelegateOptions.mjs';
 import { MessageShareOptions } from '../crypto/entities/MessageShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -38,12 +39,34 @@ export interface MessageApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateId?: string | undefined;
     }): Promise<DecryptedMessage>;
+    /**
+     *
+     *  Creates a new access log with initialized encryption metadata, specifying fine-grained options for each additional data owner that
+     *  will have access to the entity.
+     *  @param base a message with initialized content and uninitialized encryption metadata. The result of this
+     *  method takes the content from [base] if provided.
+     *  @param patient the patient linked to the Message.
+     *  @param user the current user, will be used for the auto-delegations if provided.
+     *  @param delegates additional data owners that will have access to the newly created entity. You may choose the
+     *  permissions that the delegates will have on the entity and if they will have access to the secretIds, encryptionKeys, and/or
+     *  owningEntityIds of the new entity.
+     *  @param secretId specifies which secret id of [patient] to use for the new Message
+     *  @return a message with initialized encryption metadata.
+     *  @throws IllegalArgumentException if base is not null and has a revision or has encryption metadata.
+     */
+    withEncryptionMetadataAndDelegates(base: DecryptedMessage | undefined, patient: Patient | undefined, delegates: {
+        [key: string]: MessageDelegateOptions;
+    }, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateId?: string | undefined;
+    }): Promise<DecryptedMessage>;
     /**
      *
      *  Attempts to extract the encryption keys of a message. If the user does not have access to any encryption key
      *  of the access log the method will return an empty set.
      *  Note: entities now have only one encryption key, but this method returns a set for compatibility with older
-     *  versions of iCure where this was not a guarantee.
+     *  versions of Cardinal where this was not a guarantee.
      *  @param message a message
      *  @return the encryption keys extracted from the provided Message.
      */

package/api/MessageInGroupApi.d.mts

@@ -1,4 +1,5 @@
 import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { MessageDelegateOptions } from '../crypto/entities/MessageDelegateOptions.mjs';
 import { MessageShareOptions } from '../crypto/entities/MessageShareOptions.mjs';
 import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
 import { EntityReferenceInGroup } from '../model/EntityReferenceInGroup.mjs';
@@ -27,6 +28,18 @@ export interface MessageInGroupApi {
         secretId?: SecretIdUseOption;
         alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
     }): Promise<GroupScoped<DecryptedMessage>>;
+    /**
+     *
+     *  In-group version of [MessageApi.withEncryptionMetadataAndDelegates]
+     */
+    withEncryptionMetadataAndDelegates(entityGroupId: string, base: DecryptedMessage | undefined, patient: GroupScoped<Patient> | undefined, delegates: ArrayWithUniqueKeys<{
+        delegate: EntityReferenceInGroup;
+        delegateOptions: MessageDelegateOptions;
+    }, 'delegate'>, options?: {
+        user?: User | undefined;
+        secretId?: SecretIdUseOption;
+        alternateRootDelegateReference?: EntityReferenceInGroup | undefined;
+    }): Promise<GroupScoped<DecryptedMessage>>;
     /**
      *
      *  In-group version of [MessageApi.getEncryptionKeysOf]