@icure/cardinal-sdk 3.0.0-PREVIEW-2 → 3.0.0-PREVIEW-4

package/crypto/CryptoStrategies.d.mts

@@ -4,7 +4,7 @@ import { KeypairFingerprintV1String } from "../model/specializations/KeypairFing
 import { CryptoActorStubWithType } from "../model/CryptoActorStubWithType.mjs";
 import { RecoveryResult } from "./entities/RecoveryResult.mjs";
 import { RecoveryDataKey } from "./entities/RecoveryDataKey.mjs";
-import { RsaAlgorithm, XCryptoService, XRsaKeypair } from "./CryptoService.mjs";
+import { RsaAlgorithm, RsaEncryptionAlgorithm, XCryptoService, XRsaKeypair } from "./CryptoService.mjs";
 import { CardinalApis } from "../sdk/CardinalSdk.mjs";
 /**
  * Allows customizing the behavior of the crypto api to better suit your needs.
@@ -54,21 +54,57 @@ export declare class CryptoStrategies {
      */
     generateNewKeyForDataOwner(self: DataOwnerWithType, cryptoPrimitives: XCryptoService): Promise<CryptoStrategies.KeyGenerationRequestResult>;
     /**
-     * Verifies if the public keys of a data owner which will be the delegate of a new exchange key do actually belong to the person the data owner
-     * represents. This method is not called when the delegate would be the current data owner for the api.
+     * Verifies if the public keys of a data owner which will be the delegate of new exchange data do actually belong to
+     * the person the data owner represents; if you do not override this method the public keys of the delegate are
+     * obtained from the cardinal backend and are fully trusted.
      *
-     * The user will have to obtain the verified public keys of the delegate from outside iCure, for example by email with another hcp, by checking the
-     * personal website of the other user, or by scanning verification qr codes at the doctor office...
+     * Note that this method is not called when:
+     * - The delegate id the current SDK delegator actor
+     * - The delegate is a parent type data owner linked from the current SDK delegator actor.
+     * - The SDK is creating exchange data to a simple-type group of data owners (in that case [getDelegatesPublicKeys] is used)
+     *
+     * There are two approaches you can use for verification of public keys: a separate service not controlled by iCure,
+     * or interaction with the end user.
+     *
+     * For example this method may ask the end user to compare the public keys with verified public keys of the delegate
+     * obtained from out of iCure, such as an email, the personal website of the other user, or by scanning verification
+     * qr codes at the doctor office.
+     *
+     * As long as one of the public keys is verified the creation of a new exchange key will succeed.
+     *
+     * If no public key is verified the operation will fail.
      *
-     * As long as one of the public keys is verified the creation of a new exchange key will succeed. If no public key is verified the operation will
-     * fail.
      * @param delegate the potential data owner delegate.
      * @param publicKeys public keys requiring verification, in spki hex-encoded format.
      * @param cryptoPrimitives cryptographic primitives you can use to support the process.
-     * @param groupId the id of the data owner's group, or null if the data owner is in the same group as the current user
+     * @param groupId the id of the delegate data owner's group, or null if the data owner is in the same group as the current user
      * @return all verified public keys, in spki hex-encoded format.
      */
     verifyDelegatePublicKeys(delegate: CryptoActorStubWithType, publicKeys: Array<SpkiHexString>, cryptoPrimitives: XCryptoService, groupId: string | undefined): Promise<Array<SpkiHexString>>;
+    /**
+     * Similarly to [verifyDelegatePublicKeys] this method can be used if you don't want the SDK to fully trust the
+     * public keys coming from the cardinal backend, however this method is only called when creating exchange data for
+     * a simple-type data owner group, which may require to get validated public keys for many data owners.
+     *
+     * In that case interaction with the end-user is undesired, and it would be better instead to have a dedicated
+     * service separated from cardinal that provides the public keys of your cardinal data owners.
+     *
+     * Note that:
+     * - Returning null means the SDK will retrieve public keys from the cardinal backend and fully trust them.
+     * - If this method does not return null, it must provide at least a key for each delegate
+     * - Unlike [verifyDelegatePublicKeys] this method might be called even for delegates that are parent of the current
+     *   SDK delegator actor.
+     * - The keys returned by this method will not be checked against the cardinal backend; if there are any
+     *   inconsistencies the SDK might create invalid exchange data.
+     *
+     * @param delegates delegates for which the public keys are required.
+     * @param groupId the id of the delegate data owners' group, or null if their group is the same as the current user
+     */
+    getDelegatesPublicKeys(delegates: Array<string>, groupId: string | undefined): Promise<{
+        [delegateId: string]: {
+            [publicKey: SpkiHexString]: RsaEncryptionAlgorithm;
+        };
+    } | undefined>;
     /**
      * Specifies if a data owner requires anonymous delegations, i.e. his id should not appear unencrypted in new secure
      * delegations.

package/crypto/CryptoStrategies.mjs

@@ -51,23 +51,57 @@ export class CryptoStrategies {
         return Promise.resolve(CryptoStrategies.KeyGenerationRequestResult.Allow);
     }
     /**
-     * Verifies if the public keys of a data owner which will be the delegate of a new exchange key do actually belong to the person the data owner
-     * represents. This method is not called when the delegate would be the current data owner for the api.
+     * Verifies if the public keys of a data owner which will be the delegate of new exchange data do actually belong to
+     * the person the data owner represents; if you do not override this method the public keys of the delegate are
+     * obtained from the cardinal backend and are fully trusted.
      *
-     * The user will have to obtain the verified public keys of the delegate from outside iCure, for example by email with another hcp, by checking the
-     * personal website of the other user, or by scanning verification qr codes at the doctor office...
+     * Note that this method is not called when:
+     * - The delegate id the current SDK delegator actor
+     * - The delegate is a parent type data owner linked from the current SDK delegator actor.
+     * - The SDK is creating exchange data to a simple-type group of data owners (in that case [getDelegatesPublicKeys] is used)
+     *
+     * There are two approaches you can use for verification of public keys: a separate service not controlled by iCure,
+     * or interaction with the end user.
+     *
+     * For example this method may ask the end user to compare the public keys with verified public keys of the delegate
+     * obtained from out of iCure, such as an email, the personal website of the other user, or by scanning verification
+     * qr codes at the doctor office.
+     *
+     * As long as one of the public keys is verified the creation of a new exchange key will succeed.
+     *
+     * If no public key is verified the operation will fail.
      *
-     * As long as one of the public keys is verified the creation of a new exchange key will succeed. If no public key is verified the operation will
-     * fail.
      * @param delegate the potential data owner delegate.
      * @param publicKeys public keys requiring verification, in spki hex-encoded format.
      * @param cryptoPrimitives cryptographic primitives you can use to support the process.
-     * @param groupId the id of the data owner's group, or null if the data owner is in the same group as the current user
+     * @param groupId the id of the delegate data owner's group, or null if the data owner is in the same group as the current user
      * @return all verified public keys, in spki hex-encoded format.
      */
     verifyDelegatePublicKeys(delegate, publicKeys, cryptoPrimitives, groupId) {
         return Promise.resolve(publicKeys);
     }
+    /**
+     * Similarly to [verifyDelegatePublicKeys] this method can be used if you don't want the SDK to fully trust the
+     * public keys coming from the cardinal backend, however this method is only called when creating exchange data for
+     * a simple-type data owner group, which may require to get validated public keys for many data owners.
+     *
+     * In that case interaction with the end-user is undesired, and it would be better instead to have a dedicated
+     * service separated from cardinal that provides the public keys of your cardinal data owners.
+     *
+     * Note that:
+     * - Returning null means the SDK will retrieve public keys from the cardinal backend and fully trust them.
+     * - If this method does not return null, it must provide at least a key for each delegate
+     * - Unlike [verifyDelegatePublicKeys] this method might be called even for delegates that are parent of the current
+     *   SDK delegator actor.
+     * - The keys returned by this method will not be checked against the cardinal backend; if there are any
+     *   inconsistencies the SDK might create invalid exchange data.
+     *
+     * @param delegates delegates for which the public keys are required.
+     * @param groupId the id of the delegate data owners' group, or null if their group is the same as the current user
+     */
+    getDelegatesPublicKeys(delegates, groupId) {
+        return Promise.resolve(undefined);
+    }
     /**
      * Specifies if a data owner requires anonymous delegations, i.e. his id should not appear unencrypted in new secure
      * delegations.

package/crypto/entities/BulkShareByIdsResult.d.mts

@@ -1,13 +1,15 @@
+import { EntityReferenceInGroup } from '../../model/EntityReferenceInGroup.mjs';
 import { FailedRequestDetails } from './FailedRequestDetails.mjs';
+import { SuccessfulRequestDetails } from './SuccessfulRequestDetails.mjs';
 /**
  *
  *  Outcome of a "share by ids" bulk operation: sharing many already-existing entities (retrieved server-side by id)
  *  with one or more delegates, using the same share options for the whole batch.
  *
  *  For every entity id that was found (i.e. not in [notFoundIds]) and every delegate the operation was called with,
- *  that (entity id, delegate id) pair is accounted for in exactly one place: as a delegate id under that entity id in
- *  [successfulDelegateIdsByEntityId], as a delegate id under that entity id in [unmodifiedDelegateIdsByEntityId], or
- *  as an entry in [shareErrors] - never in more than one of these, and never in none of them.
+ *  that (entity id, delegate) pair is accounted for in exactly one place: as a successful request under that entity id
+ *  in [successfulRequestsByEntityId], as a delegate under that entity id in [unmodifiedDelegatesByEntityId], or as an
+ *  entry in [shareErrors] - never in more than one of these, and never in none of them.
  */
 export declare class BulkShareByIdsResult {
     /**
@@ -19,24 +21,27 @@ export declare class BulkShareByIdsResult {
     notFoundIds: Array<string>;
     /**
      *
-     *  For each entity id, the ids of the delegates for which a share request was actually sent and succeeded. An
-     *  entity id with no successful delegate to report is simply absent from this map - it never appears with an
-     *  empty set.
+     *  For each entity id, the requests that were actually sent for that entity and succeeded, one per delegate. An
+     *  entity id with no successful request to report is simply absent from this map - it never appears with an empty
+     *  set.
+     *
+     *  In addition to the requested delegates this may contain requests for delegates the operation was not called
+     *  with, recognisable by a [ShareRequestPurpose.Migration] purpose: see [shareErrors] for what those are.
      */
-    successfulDelegateIdsByEntityId: {
-        [key: string]: Array<string>;
+    successfulRequestsByEntityId: {
+        [key: string]: Array<SuccessfulRequestDetails>;
     };
     /**
      *
-     *  For each entity id, the ids of the delegates for which no update request had to be sent at all, because that
-     *  delegate already had access to everything requested with a sufficient access level. This is tracked per
-     *  delegate, not per entity: if an entity was shared with two delegates and only one of them already had
-     *  everything, only that delegate's id ends up here - the other one ends up under
-     *  [successfulDelegateIdsByEntityId] or in [shareErrors] instead. An entity id with no unmodified delegate to
-     *  report is simply absent from this map - it never appears with an empty set.
+     *  For each entity id, the delegates for which no update request had to be sent at all, because that delegate
+     *  already had access to everything requested with a sufficient access level. This is tracked per delegate, not
+     *  per entity: if an entity was shared with two delegates and only one of them already had everything, only that
+     *  delegate ends up here - the other one ends up under [successfulRequestsByEntityId] or in [shareErrors]
+     *  instead. An entity id with no unmodified delegate to report is simply absent from this map - it never appears
+     *  with an empty set.
      */
-    unmodifiedDelegateIdsByEntityId: {
-        [key: string]: Array<string>;
+    unmodifiedDelegatesByEntityId: {
+        [key: string]: Array<EntityReferenceInGroup>;
     };
     /**
      *
@@ -44,7 +49,16 @@ export declare class BulkShareByIdsResult {
      *  the distinction between a [FailedRequestDetails.ResolutionFailed] (the requested share options couldn't be
      *  satisfied locally, e.g. [ShareMetadataBehaviour.Required] was asked for something unavailable) and a
      *  [FailedRequestDetails.RequestRejected] (a well-formed request was sent and the server rejected it).
+     *
+     *  In addition to the requested delegates this may contain entries for delegates the operation was not called
+     *  with: those are the internal requests the sdk piggybacks on a share to migrate the legacy delegations of the
+     *  current data owner hierarchy, and they carry a [ShareRequestPurpose.Migration] purpose. A failure of such a
+     *  request means the migration didn't happen, not that the requested sharing didn't (the requested sharing of a
+     *  delegate that was not requested was, by definition, not requested). When a requested delegate is also a data
+     *  owner whose legacy delegations need to be migrated the two are done by a single request, whose purpose is
+     *  [ShareRequestPurpose.RequestedShareAndMigration]: a failure of that one does mean the requested sharing
+     *  failed.
      */
     shareErrors: Array<FailedRequestDetails>;
-    constructor(partial: Partial<BulkShareByIdsResult> & Pick<BulkShareByIdsResult, "notFoundIds" | "successfulDelegateIdsByEntityId" | "unmodifiedDelegateIdsByEntityId" | "shareErrors">);
+    constructor(partial: Partial<BulkShareByIdsResult> & Pick<BulkShareByIdsResult, "notFoundIds" | "successfulRequestsByEntityId" | "unmodifiedDelegatesByEntityId" | "shareErrors">);
 }

package/crypto/entities/BulkShareByIdsResult.mjs

@@ -4,15 +4,15 @@
  *  with one or more delegates, using the same share options for the whole batch.
  *
  *  For every entity id that was found (i.e. not in [notFoundIds]) and every delegate the operation was called with,
- *  that (entity id, delegate id) pair is accounted for in exactly one place: as a delegate id under that entity id in
- *  [successfulDelegateIdsByEntityId], as a delegate id under that entity id in [unmodifiedDelegateIdsByEntityId], or
- *  as an entry in [shareErrors] - never in more than one of these, and never in none of them.
+ *  that (entity id, delegate) pair is accounted for in exactly one place: as a successful request under that entity id
+ *  in [successfulRequestsByEntityId], as a delegate under that entity id in [unmodifiedDelegatesByEntityId], or as an
+ *  entry in [shareErrors] - never in more than one of these, and never in none of them.
  */
 export class BulkShareByIdsResult {
     constructor(partial) {
         this.notFoundIds = partial.notFoundIds;
-        this.successfulDelegateIdsByEntityId = partial.successfulDelegateIdsByEntityId;
-        this.unmodifiedDelegateIdsByEntityId = partial.unmodifiedDelegateIdsByEntityId;
+        this.successfulRequestsByEntityId = partial.successfulRequestsByEntityId;
+        this.unmodifiedDelegatesByEntityId = partial.unmodifiedDelegatesByEntityId;
         this.shareErrors = partial.shareErrors;
     }
 }

package/crypto/entities/FailedRequestDetails.d.mts

@@ -1,5 +1,6 @@
 import { EntityReferenceInGroup } from '../../model/EntityReferenceInGroup.mjs';
-import { DelegateShareOptions } from './DelegateShareOptions.mjs';
+import { ShareRequestPurpose } from './ShareRequestPurpose.mjs';
+import { ShareRequestSummary } from './ShareRequestSummary.mjs';
 /**
  *
  *  Details about a single (entity, delegate) share-or-metadata-update request that did not succeed, returned as part
@@ -46,11 +47,14 @@ export declare namespace FailedRequestDetails {
      *  @param shouldRetry whether the SDK considers this specific failure worth retrying (e.g. with a freshly
      *  fetched revision of the entity). Bulk operations that support `autoRetry` already do this automatically once
      *  before giving up, so by the time you observe this you can assume that retry (if applicable) already happened.
-     *  @param updatedForMigration `true` if this request wasn't actually about sharing or updating access for
-     *  [delegateReference], but rather an internal step to migrate that delegate's pre-existing legacy delegation to
-     *  the current secure-delegation format. Most callers can ignore this field.
-     *  @param request the low-level share options that were sent to the server for this (entity, delegate) pair, or
-     *  `null` if this was an [updatedForMigration] request (which doesn't carry share options of its own).
+     *  @param purpose what the rejected request was for. Most callers can ignore this field: it is
+     *  [ShareRequestPurpose.RequestedShare] for a plain share, and the two other values only tell you that the sdk also
+     *  had (or only had) to migrate the legacy delegations of [delegateReference] along the way.
+     *  @param requestSummary a non-sensitive summary of what the rejected request was asking for, to help understand
+     *  why it was rejected. `null` when the sdk didn't resolve any share options for this pair on the caller's behalf,
+     *  i.e. when [purpose] is [ShareRequestPurpose.Migration], or when the caller used one of the lower-level share
+     *  methods that take an already resolved [DelegateShareOptions] (in which case the caller already holds the exact
+     *  options that were sent).
      */
     class RequestRejected {
         entityId: string;
@@ -58,9 +62,9 @@ export declare namespace FailedRequestDetails {
         reason: string | undefined;
         code: number;
         shouldRetry: boolean;
-        updatedForMigration: boolean;
-        request: DelegateShareOptions | undefined;
+        purpose: ShareRequestPurpose;
+        requestSummary: ShareRequestSummary | undefined;
         readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.FailedRequestDetails.RequestRejected';
-        constructor(partial: Partial<RequestRejected> & Pick<RequestRejected, "entityId" | "delegateReference" | "reason" | "code" | "shouldRetry" | "updatedForMigration" | "request">);
+        constructor(partial: Partial<RequestRejected> & Pick<RequestRejected, "entityId" | "delegateReference" | "reason" | "code" | "shouldRetry" | "purpose" | "requestSummary">);
     }
 }

package/crypto/entities/FailedRequestDetails.mjs

@@ -38,11 +38,14 @@ export var FailedRequestDetails;
      *  @param shouldRetry whether the SDK considers this specific failure worth retrying (e.g. with a freshly
      *  fetched revision of the entity). Bulk operations that support `autoRetry` already do this automatically once
      *  before giving up, so by the time you observe this you can assume that retry (if applicable) already happened.
-     *  @param updatedForMigration `true` if this request wasn't actually about sharing or updating access for
-     *  [delegateReference], but rather an internal step to migrate that delegate's pre-existing legacy delegation to
-     *  the current secure-delegation format. Most callers can ignore this field.
-     *  @param request the low-level share options that were sent to the server for this (entity, delegate) pair, or
-     *  `null` if this was an [updatedForMigration] request (which doesn't carry share options of its own).
+     *  @param purpose what the rejected request was for. Most callers can ignore this field: it is
+     *  [ShareRequestPurpose.RequestedShare] for a plain share, and the two other values only tell you that the sdk also
+     *  had (or only had) to migrate the legacy delegations of [delegateReference] along the way.
+     *  @param requestSummary a non-sensitive summary of what the rejected request was asking for, to help understand
+     *  why it was rejected. `null` when the sdk didn't resolve any share options for this pair on the caller's behalf,
+     *  i.e. when [purpose] is [ShareRequestPurpose.Migration], or when the caller used one of the lower-level share
+     *  methods that take an already resolved [DelegateShareOptions] (in which case the caller already holds the exact
+     *  options that were sent).
      */
     class RequestRejected {
         constructor(partial) {
@@ -52,8 +55,8 @@ export var FailedRequestDetails;
             this.reason = partial.reason;
             this.code = partial.code;
             this.shouldRetry = partial.shouldRetry;
-            this.updatedForMigration = partial.updatedForMigration;
-            this.request = partial.request;
+            this.purpose = partial.purpose;
+            this.requestSummary = partial.requestSummary;
         }
     }
     FailedRequestDetails.RequestRejected = RequestRejected;

package/crypto/entities/SecretIdShareOptions.d.mts

@@ -10,6 +10,10 @@ export declare namespace SecretIdShareOptions {
      *  @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
      */
     class AllAvailable {
+        /**
+         * Share all available secret ids
+         * @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
+         * / */
         requireAtLeastOne: boolean;
         readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.SecretIdShareOptions.AllAvailable';
         constructor(partial: Partial<AllAvailable>);

package/crypto/entities/SecretIdShareOptions.mjs

@@ -8,6 +8,10 @@ export var SecretIdShareOptions;
      */
     class AllAvailable {
         constructor(partial) {
+            /**
+             * Share all available secret ids
+             * @param requireAtLeastOne if true the sharing will fail if the current user can't access any secret id of the entity
+             * / */
             this.requireAtLeastOne = false;
             this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.SecretIdShareOptions.AllAvailable';
             if ('requireAtLeastOne' in partial && partial.requireAtLeastOne !== undefined)

package/crypto/entities/SecretIdUseOption.d.mts

@@ -18,6 +18,11 @@ export declare namespace SecretIdUseOption {
      *  Note that the SDK will not check that the secret id you used is actually a secret id of the owning entity.
      */
     class Use {
+        /**
+         * Specify explicitly which secret ids to use. The secretIds can also be empty, in which case the value is
+         * equivalent to [UseNone].
+         * Note that the SDK will not check that the secret id you used is actually a secret id of the owning entity.
+         * / */
         secretIds: Array<string>;
         readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.SecretIdUseOption.Use';
         constructor(partial: Partial<Use> & Pick<Use, "secretIds">);

package/crypto/entities/ShareAllPatientDataOptions.d.mts

@@ -0,0 +1,49 @@
+import { EncryptedPatient } from '../../model/Patient.mjs';
+import { FailedRequestDetails } from './FailedRequestDetails.mjs';
+import { ShareAllPatientDataOptions as ShareAllPatientDataOptions_ } from './ShareAllPatientDataOptions.mjs';
+export declare namespace ShareAllPatientDataOptions {
+    /**
+     *
+     *  Specifies which entities related to a Patient will be shared by [PatientApi.shareAllDataOfPatient].
+     */
+    enum Tag {
+        All = "All",
+        MedicalInformation = "MedicalInformation",
+        FinancialInformation = "FinancialInformation"
+    }
+    enum ShareableEntity {
+        CalendarItem = "CalendarItem",
+        Contact = "Contact",
+        Classification = "Classification",
+        Document = "Document",
+        Form = "Form",
+        HealthElement = "HealthElement",
+        Invoice = "Invoice",
+        Patient = "Patient"
+    }
+    class EntityResult {
+        success: boolean | undefined;
+        error: ShareAllPatientDataOptions_.SharePatientDataError | undefined;
+        modified: number;
+        constructor(partial: Partial<EntityResult> & Pick<EntityResult, "modified">);
+    }
+    class Result {
+        patient: EncryptedPatient;
+        statuses: {
+            [key in ShareAllPatientDataOptions_.ShareableEntity]?: ShareAllPatientDataOptions_.EntityResult;
+        };
+        constructor(partial: Partial<Result> & Pick<Result, "patient" | "statuses">);
+    }
+    type SharePatientDataError = BulkShareFailure | FailedRequest;
+    class BulkShareFailure {
+        errors: Array<FailedRequestDetails>;
+        message: string;
+        readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.BulkShareFailure';
+        constructor(partial: Partial<BulkShareFailure> & Pick<BulkShareFailure, "errors" | "message">);
+    }
+    class FailedRequest {
+        description: string;
+        readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.FailedRequest';
+        constructor(partial: Partial<FailedRequest> & Pick<FailedRequest, "description">);
+    }
+}

package/crypto/entities/ShareAllPatientDataOptions.mjs

@@ -0,0 +1,58 @@
+export var ShareAllPatientDataOptions;
+(function (ShareAllPatientDataOptions) {
+    /**
+     *
+     *  Specifies which entities related to a Patient will be shared by [PatientApi.shareAllDataOfPatient].
+     */
+    let Tag;
+    (function (Tag) {
+        Tag["All"] = "All";
+        Tag["MedicalInformation"] = "MedicalInformation";
+        Tag["FinancialInformation"] = "FinancialInformation";
+    })(Tag = ShareAllPatientDataOptions.Tag || (ShareAllPatientDataOptions.Tag = {}));
+    let ShareableEntity;
+    (function (ShareableEntity) {
+        ShareableEntity["CalendarItem"] = "CalendarItem";
+        ShareableEntity["Contact"] = "Contact";
+        ShareableEntity["Classification"] = "Classification";
+        ShareableEntity["Document"] = "Document";
+        ShareableEntity["Form"] = "Form";
+        ShareableEntity["HealthElement"] = "HealthElement";
+        ShareableEntity["Invoice"] = "Invoice";
+        ShareableEntity["Patient"] = "Patient";
+    })(ShareableEntity = ShareAllPatientDataOptions.ShareableEntity || (ShareAllPatientDataOptions.ShareableEntity = {}));
+    class EntityResult {
+        constructor(partial) {
+            this.success = undefined;
+            this.error = undefined;
+            if ('success' in partial)
+                this.success = partial.success;
+            if ('error' in partial)
+                this.error = partial.error;
+            this.modified = partial.modified;
+        }
+    }
+    ShareAllPatientDataOptions.EntityResult = EntityResult;
+    class Result {
+        constructor(partial) {
+            this.patient = partial.patient;
+            this.statuses = partial.statuses;
+        }
+    }
+    ShareAllPatientDataOptions.Result = Result;
+    class BulkShareFailure {
+        constructor(partial) {
+            this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.BulkShareFailure';
+            this.errors = partial.errors;
+            this.message = partial.message;
+        }
+    }
+    ShareAllPatientDataOptions.BulkShareFailure = BulkShareFailure;
+    class FailedRequest {
+        constructor(partial) {
+            this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.FailedRequest';
+            this.description = partial.description;
+        }
+    }
+    ShareAllPatientDataOptions.FailedRequest = FailedRequest;
+})(ShareAllPatientDataOptions || (ShareAllPatientDataOptions = {}));

package/crypto/entities/ShareRequestPurpose.d.mts

@@ -0,0 +1,12 @@
+/**
+ *
+ *  What a single share-or-metadata-update request the sdk sent was actually for. Sharing an entity may require the sdk
+ *  to also migrate the pre-existing legacy delegations of the data owners of the current hierarchy to the current
+ *  secure-delegation format, and those migrations travel as requests of their own - sometimes merged with a request
+ *  the caller asked for.
+ */
+export declare enum ShareRequestPurpose {
+    RequestedShare = "RequestedShare",
+    Migration = "Migration",
+    RequestedShareAndMigration = "RequestedShareAndMigration"
+}

package/crypto/entities/ShareRequestPurpose.mjs

@@ -0,0 +1,14 @@
+// auto-generated file
+/**
+ *
+ *  What a single share-or-metadata-update request the sdk sent was actually for. Sharing an entity may require the sdk
+ *  to also migrate the pre-existing legacy delegations of the data owners of the current hierarchy to the current
+ *  secure-delegation format, and those migrations travel as requests of their own - sometimes merged with a request
+ *  the caller asked for.
+ */
+export var ShareRequestPurpose;
+(function (ShareRequestPurpose) {
+    ShareRequestPurpose["RequestedShare"] = "RequestedShare";
+    ShareRequestPurpose["Migration"] = "Migration";
+    ShareRequestPurpose["RequestedShareAndMigration"] = "RequestedShareAndMigration";
+})(ShareRequestPurpose || (ShareRequestPurpose = {}));

package/crypto/entities/ShareRequestSummary.d.mts

@@ -0,0 +1,51 @@
+import { RequestedPermission } from '../../model/requests/RequestedPermission.mjs';
+import { ShareMetadataBehaviour } from './ShareMetadataBehaviour.mjs';
+import { SharedSecretIdsSource } from './SharedSecretIdsSource.mjs';
+/**
+ *
+ *  A non-sensitive summary of a share request the sdk built out of the share options provided by the caller: what was
+ *  asked for each kind of metadata and how much of it the request was carrying, but never the metadata itself -
+ *  sharing a secret id or an encryption key means putting the actual value in the request, and those values must not
+ *  end up in an error object that callers routinely log.
+ *
+ *  The counts are those of the resolved request, before the sdk dropped from it whatever the delegate can already
+ *  access anyway (see [FailedRequestDetails.RequestRejected.requestSummary] for when you get one of these).
+ */
+export declare class ShareRequestSummary {
+    /**
+     *
+     *  The permissions that were requested for the delegate.
+     */
+    requestedPermissions: RequestedPermission;
+    /**
+     *
+     *  Where the secret ids of the request came from.
+     */
+    secretIdsSource: SharedSecretIdsSource;
+    /**
+     *
+     *  How many secret ids the request was carrying.
+     */
+    sharedSecretIdsCount: number;
+    /**
+     *
+     *  The behaviour that was requested for the encryption key.
+     */
+    encryptionKeysBehaviour: ShareMetadataBehaviour;
+    /**
+     *
+     *  How many encryption keys the request was carrying.
+     */
+    sharedEncryptionKeysCount: number;
+    /**
+     *
+     *  The behaviour that was requested for the owning entity ids.
+     */
+    owningEntityIdsBehaviour: ShareMetadataBehaviour;
+    /**
+     *
+     *  How many owning entity ids the request was carrying.
+     */
+    sharedOwningEntityIdsCount: number;
+    constructor(partial: Partial<ShareRequestSummary> & Pick<ShareRequestSummary, "requestedPermissions" | "secretIdsSource" | "sharedSecretIdsCount" | "encryptionKeysBehaviour" | "sharedEncryptionKeysCount" | "owningEntityIdsBehaviour" | "sharedOwningEntityIdsCount">);
+}

package/crypto/entities/ShareRequestSummary.mjs

@@ -0,0 +1,21 @@
+/**
+ *
+ *  A non-sensitive summary of a share request the sdk built out of the share options provided by the caller: what was
+ *  asked for each kind of metadata and how much of it the request was carrying, but never the metadata itself -
+ *  sharing a secret id or an encryption key means putting the actual value in the request, and those values must not
+ *  end up in an error object that callers routinely log.
+ *
+ *  The counts are those of the resolved request, before the sdk dropped from it whatever the delegate can already
+ *  access anyway (see [FailedRequestDetails.RequestRejected.requestSummary] for when you get one of these).
+ */
+export class ShareRequestSummary {
+    constructor(partial) {
+        this.requestedPermissions = partial.requestedPermissions;
+        this.secretIdsSource = partial.secretIdsSource;
+        this.sharedSecretIdsCount = partial.sharedSecretIdsCount;
+        this.encryptionKeysBehaviour = partial.encryptionKeysBehaviour;
+        this.sharedEncryptionKeysCount = partial.sharedEncryptionKeysCount;
+        this.owningEntityIdsBehaviour = partial.owningEntityIdsBehaviour;
+        this.sharedOwningEntityIdsCount = partial.sharedOwningEntityIdsCount;
+    }
+}

package/crypto/entities/SharedSecretIdsSource.d.mts

@@ -0,0 +1,8 @@
+/**
+ *
+ *  Whether the secret ids carried by a share request were chosen by the caller or by the sdk.
+ */
+export declare enum SharedSecretIdsSource {
+    AllAvailable = "AllAvailable",
+    ExplicitValues = "ExplicitValues"
+}

package/crypto/entities/SharedSecretIdsSource.mjs

@@ -0,0 +1,10 @@
+// auto-generated file
+/**
+ *
+ *  Whether the secret ids carried by a share request were chosen by the caller or by the sdk.
+ */
+export var SharedSecretIdsSource;
+(function (SharedSecretIdsSource) {
+    SharedSecretIdsSource["AllAvailable"] = "AllAvailable";
+    SharedSecretIdsSource["ExplicitValues"] = "ExplicitValues";
+})(SharedSecretIdsSource || (SharedSecretIdsSource = {}));

package/crypto/entities/SuccessfulRequestDetails.d.mts

@@ -0,0 +1,22 @@
+import { EntityReferenceInGroup } from '../../model/EntityReferenceInGroup.mjs';
+import { ShareRequestPurpose } from './ShareRequestPurpose.mjs';
+/**
+ *
+ *  Details about a single (entity, delegate) share-or-metadata-update request that was sent and succeeded, returned as
+ *  part of the success map of a bulk-share operation (e.g. [BulkShareByIdsResult.successfulRequestsByEntityId]).
+ */
+export declare class SuccessfulRequestDetails {
+    /**
+     *
+     *  The delegate this request shared with, or updated the delegation of.
+     */
+    delegateReference: EntityReferenceInGroup;
+    /**
+     *
+     *  What this request was for. Most callers can ignore this field: it is [ShareRequestPurpose.RequestedShare] for a
+     *  plain share, and the two other values only tell you that the sdk also had (or only had) to migrate the legacy
+     *  delegations of that data owner along the way.
+     */
+    purpose: ShareRequestPurpose;
+    constructor(partial: Partial<SuccessfulRequestDetails> & Pick<SuccessfulRequestDetails, "delegateReference" | "purpose">);
+}

package/crypto/entities/SuccessfulRequestDetails.mjs

@@ -0,0 +1,11 @@
+/**
+ *
+ *  Details about a single (entity, delegate) share-or-metadata-update request that was sent and succeeded, returned as
+ *  part of the success map of a bulk-share operation (e.g. [BulkShareByIdsResult.successfulRequestsByEntityId]).
+ */
+export class SuccessfulRequestDetails {
+    constructor(partial) {
+        this.delegateReference = partial.delegateReference;
+        this.purpose = partial.purpose;
+    }
+}