@icure/cardinal-sdk 2.0.0-PREVIEW-18.1 → 2.0.0-PREVIEW-21

package/api/HealthcarePartyApi.d.mts

@@ -8,7 +8,9 @@ import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
 import { EntitySubscription } from '../subscription/EntitySubscription.mjs';
 import { EntitySubscriptionConfiguration } from '../subscription/EntitySubscriptionConfiguration.mjs';
 import { SubscriptionEventType } from '../subscription/SubscriptionEventType.mjs';
+import { HealthcarePartyApiInGroup } from './HealthcarePartyApiInGroup.mjs';
 export interface HealthcarePartyApi {
+    inGroup: HealthcarePartyApiInGroup;
     deleteHealthcarePartyUnsafe(entityId: string): Promise<DocIdentifier>;
     deleteHealthcarePartiesUnsafe(entityIds: Array<string>): Promise<Array<DocIdentifier>>;
     getHealthcareParty(healthcarePartyId: string): Promise<HealthcareParty | undefined>;

package/api/HealthcarePartyApiInGroup.d.mts

@@ -0,0 +1,5 @@
+import { BaseFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { HealthcareParty } from '../model/HealthcareParty.mjs';
+export interface HealthcarePartyApiInGroup {
+    matchHealthcarePartiesBy(groupId: string, filter: BaseFilterOptions<HealthcareParty>): Promise<Array<string>>;
+}

package/api/HealthcarePartyApiInGroup.mjs

@@ -0,0 +1 @@
+export {};

package/api/RecoveryApi.d.mts

@@ -1,4 +1,5 @@
 import { XRsaKeypair } from '../cardinal-sdk-ts.mjs';
+import { RawDecryptedExchangeData } from '../crypto/entities/RawDecryptedExchangeData.mjs';
 import { RecoveryDataKey } from '../crypto/entities/RecoveryDataKey.mjs';
 import { RecoveryDataUseFailureReason } from '../crypto/entities/RecoveryDataUseFailureReason.mjs';
 import { RecoveryKeyOptions } from '../crypto/entities/RecoveryKeyOptions.mjs';
@@ -24,8 +25,11 @@ export interface RecoveryApi {
     createExchangeDataRecoveryInfo(delegateId: string, options?: {
         lifetimeSeconds?: number | undefined;
         recoveryKeyOptions?: RecoveryKeyOptions | undefined;
-    }): Promise<RecoveryDataKey>;
+        includeBiDirectional?: boolean;
+        includeAsParent?: boolean;
+    }): Promise<RecoveryDataKey | undefined>;
     recoverExchangeData(recoveryKey: RecoveryDataKey): Promise<RecoveryDataUseFailureReason | undefined>;
+    getRecoveryExchangeData(recoveryKey: RecoveryDataKey, autoDelete: boolean): Promise<RecoveryResult<Array<RawDecryptedExchangeData>>>;
     purgeRecoveryInfo(recoveryKey: RecoveryDataKey): Promise<void>;
     purgeAllRecoveryInfoFor(dataOwnerId: string): Promise<number>;
     purgeAllKeyPairRecoveryInfoFor(dataOwnerId: string): Promise<number>;

package/api.d.mts

@@ -64,6 +64,7 @@ export * from './api/CalendarItemFlavouredInGroupApi.mjs';
 export * from './api/AgendaApi.mjs';
 export * from './api/DocumentFlavouredApi.mjs';
 export * from './api/FormBasicApi.mjs';
+export * from './api/HealthcarePartyApiInGroup.mjs';
 export * from './api/ClassificationApi.mjs';
 export * from './api/RecoveryApi.mjs';
 export * from './api/PermissionApi.mjs';

package/api.mjs

@@ -64,6 +64,7 @@ export * from './api/CalendarItemFlavouredInGroupApi.mjs';
 export * from './api/AgendaApi.mjs';
 export * from './api/DocumentFlavouredApi.mjs';
 export * from './api/FormBasicApi.mjs';
+export * from './api/HealthcarePartyApiInGroup.mjs';
 export * from './api/ClassificationApi.mjs';
 export * from './api/RecoveryApi.mjs';
 export * from './api/PermissionApi.mjs';

package/bitops-library-bits.mjs

@@ -0,0 +1,197 @@
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  toString1pkumu07cwy4m as toString,
+  IllegalArgumentException_init_$Create$3ewkh27kzt8z8 as IllegalArgumentException_init_$Create$,
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  VOID3gxj6tk5isa35 as VOID,
+  hashCodeq5arwsb9dgti as hashCode,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+} from './kotlin-kotlin-stdlib.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForClass(Final_1, 'Final');
+initMetadataForClass(Final, 'Final', VOID, Final_1);
+initMetadataForClass(Final_0, 'Final', VOID, Final_1);
+initMetadataForClass(Counter, 'Counter');
+initMetadataForClass(Bit32, 'Bit32', VOID, Counter);
+initMetadataForClass(Bit64, 'Bit64', VOID, Counter);
+//endregion
+function Final_init_$Init$(lo, hi, $this) {
+  Final.call($this, lo, hi, false);
+  return $this;
+}
+function Final_init_$Create$(lo, hi) {
+  return Final_init_$Init$(lo, hi, objectCreate(protoOf(Final)));
+}
+function Companion() {
+  this.q6y_1 = 1048576;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function Bit32_init_$Init$(lo, hi, incrementBy, $this) {
+  Counter.call($this);
+  Bit32.call($this);
+  // Inline function 'kotlin.require' call
+  if (!(incrementBy > 0)) {
+    var message = 'incrementBy[' + incrementBy + '] must be greater than 0';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(incrementBy <= 1048576)) {
+    var message_0 = 'incrementBy[' + incrementBy + '] must be less than or equal to 1048576';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!((incrementBy % 8 | 0) === 0)) {
+    var message_1 = 'incrementBy[' + incrementBy + '] must be a factor of 8';
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+  // Inline function 'kotlin.require' call
+  if (!((-2147483648 % incrementBy | 0) === 0)) {
+    var message_2 = 'Int.MIN_VALUE % incrementBy[' + incrementBy + '] != 0';
+    throw IllegalArgumentException_init_$Create$(toString(message_2));
+  }
+  // Inline function 'kotlin.require' call
+  if (!((lo % incrementBy | 0) === 0)) {
+    var message_3 = 'lo must be a factor of incrementBy[' + incrementBy + ']';
+    throw IllegalArgumentException_init_$Create$(toString(message_3));
+  }
+  $this.s6y_1 = incrementBy;
+  $this.t6y_1 = lo;
+  $this.u6y_1 = hi;
+  return $this;
+}
+function Bit32_init_$Init$_0(incrementBy, $this) {
+  Bit32_init_$Init$(0, 0, incrementBy, $this);
+  return $this;
+}
+function Bit32_init_$Create$(incrementBy) {
+  return Bit32_init_$Init$_0(incrementBy, objectCreate(protoOf(Bit32)));
+}
+function Final(lo, hi, isBits) {
+  Final_1.call(this, isBits);
+  this.w6y_1 = lo;
+  this.x6y_1 = hi;
+}
+protoOf(Final).na = function () {
+  return this.w6y_1;
+};
+protoOf(Final).oa = function () {
+  return this.x6y_1;
+};
+protoOf(Final).y6y = function () {
+  if (this.z6y_1)
+    return this;
+  return new Final(this.w6y_1 << 3, this.x6y_1 << 3 | (this.w6y_1 >>> 29 | 0), true);
+};
+function Final_0() {
+}
+protoOf(Bit32).a6z = function () {
+  this.t6y_1 = this.t6y_1 + this.s6y_1 | 0;
+  if (this.t6y_1 === 0) {
+    this.u6y_1 = this.u6y_1 + 1 | 0;
+  }
+};
+protoOf(Bit32).b6z = function (additional) {
+  var lo = this.t6y_1;
+  var hi = this.u6y_1;
+  var lt0 = lo < 0;
+  lo = lo + additional | 0;
+  if (lt0 && lo >= 0) {
+    hi = hi + 1 | 0;
+  }
+  return Final_init_$Create$(lo, hi);
+};
+protoOf(Bit32).c6z = function () {
+  this.t6y_1 = 0;
+  this.u6y_1 = 0;
+};
+function Bit32() {
+}
+function Bit64() {
+}
+function Final_1(isBits) {
+  this.z6y_1 = isBits;
+}
+protoOf(Final_1).equals = function (other) {
+  var tmp;
+  if (other instanceof Final_1) {
+    tmp = hashCode(other) === this.hashCode();
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(Final_1).hashCode = function () {
+  var result = 17;
+  if (this instanceof Final) {
+    result = imul(result, 31) + this.w6y_1 | 0;
+    result = imul(result, 31) + this.x6y_1 | 0;
+  } else {
+    if (this instanceof Final_0) {
+      result = imul(result, 31) + this.e6z_1.hashCode() | 0;
+      result = imul(result, 31) + this.f6z_1.hashCode() | 0;
+    }
+  }
+  result = imul(result, 31) + getBooleanHashCode(this.z6y_1) | 0;
+  return result;
+};
+protoOf(Final_1).toString = function () {
+  var tmp;
+  if (this instanceof Final) {
+    tmp = 'Counter.Bit32.Final[lo=' + this.w6y_1 + ', hi=' + this.x6y_1 + ']';
+  } else {
+    if (this instanceof Final_0) {
+      tmp = 'Counter.Bit64.Final[lo=' + this.e6z_1.toString() + ', hi=' + this.f6z_1.toString() + ']';
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+  return tmp;
+};
+function Counter() {
+  this.g6z_1 = new Object();
+}
+protoOf(Counter).equals = function (other) {
+  var tmp;
+  if (other instanceof Counter) {
+    tmp = hashCode(other) === this.hashCode();
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(Counter).hashCode = function () {
+  return 527 + hashCode(this.g6z_1) | 0;
+};
+protoOf(Counter).toString = function () {
+  var tmp;
+  if (this instanceof Bit32) {
+    tmp = 'Bit32[lo=' + this.t6y_1 + ', hi=' + this.u6y_1 + ', incrementBy=' + this.s6y_1 + ']';
+  } else {
+    if (this instanceof Bit64) {
+      tmp = 'Bit64[lo=' + this.j6z_1.toString() + ', hi=' + this.k6z_1.toString() + ', incrementBy=' + this.i6z_1.toString() + ']';
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+  // Inline function 'kotlin.let' call
+  return 'Counter.' + tmp + '@' + this.hashCode();
+};
+//region block: init
+Companion_instance = new Companion();
+//endregion
+//region block: exports
+export {
+  Bit32_init_$Create$ as Bit32_init_$Create$3semccfol7xke,
+};
+//endregion

package/bitops-library-endian.mjs

@@ -0,0 +1,117 @@
+import {
+  toByte4i43936u611k as toByte,
+  protoOf180f3jzyo7rfj as protoOf,
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  getKClass3t8tygqu4lcxf as getKClass,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  VOID3gxj6tk5isa35 as VOID,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from './kotlin-kotlin-stdlib.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForClass(Endian, 'Endian');
+initMetadataForObject(Big, 'Big', VOID, Endian);
+initMetadataForObject(Little, 'Little', VOID, Endian);
+initMetadataForCompanion(Companion);
+//endregion
+function Big() {
+  Big_instance = this;
+  Endian.call(this);
+}
+protoOf(Big).l6z = function (source, dest, destOffset) {
+  // Inline function 'org.kotlincrypto.bitops.endian.internal.packBEInt' call
+  dest[destOffset] = toByte(source >>> 24 | 0);
+  dest[destOffset + 1 | 0] = toByte(source >>> 16 | 0);
+  dest[destOffset + 2 | 0] = toByte(source >>> 8 | 0);
+  dest[destOffset + 3 | 0] = toByte(source);
+  return dest;
+};
+protoOf(Big).m6z = function (source, dest, destOffset, sourceIndexStart, sourceIndexEnd) {
+  // Inline function 'org.kotlincrypto.bitops.endian.internal.packArray' call
+  var destPos = destOffset;
+  var sourcePos = sourceIndexStart;
+  while (sourcePos < sourceIndexEnd) {
+    var tmp0 = sourcePos;
+    sourcePos = tmp0 + 1 | 0;
+    var destPos_0 = destPos;
+    // Inline function 'org.kotlincrypto.bitops.endian.internal.packBEInt' call
+    var source_0 = source[tmp0];
+    dest[destPos_0] = toByte(source_0 >>> 24 | 0);
+    dest[destPos_0 + 1 | 0] = toByte(source_0 >>> 16 | 0);
+    dest[destPos_0 + 2 | 0] = toByte(source_0 >>> 8 | 0);
+    dest[destPos_0 + 3 | 0] = toByte(source_0);
+    destPos = destPos + 4 | 0;
+  }
+  return dest;
+};
+protoOf(Big).n6z = function (source, dest, destOffset, sourceIndexStart, sourceIndexEnd) {
+  // Inline function 'org.kotlincrypto.bitops.endian.internal.packArray' call
+  var destPos = destOffset;
+  var sourcePos = sourceIndexStart;
+  while (sourcePos < sourceIndexEnd) {
+    var tmp2 = sourcePos;
+    var tmp0 = destPos;
+    destPos = tmp0 + 1 | 0;
+    // Inline function 'org.kotlincrypto.bitops.endian.internal.unpackBEInt' call
+    var tmp0_0 = _B0___init__impl__6otxhp(source[tmp2]);
+    var tmp2_0 = source[tmp2 + 1 | 0];
+    var tmp4 = source[tmp2 + 2 | 0];
+    // Inline function 'org.kotlincrypto.bitops.endian.internal.toBEInt' call
+    var b3 = source[tmp2 + 3 | 0];
+    dest[tmp0] = _B0___get_b0__impl__g161pk(tmp0_0) << 24 | (tmp2_0 & 255) << 16 | (tmp4 & 255) << 8 | b3 & 255;
+    sourcePos = sourcePos + 4 | 0;
+  }
+  return dest;
+};
+protoOf(Big).equals = function (other) {
+  return other instanceof Big;
+};
+protoOf(Big).hashCode = function () {
+  return 527 + getKClass(Big).hashCode() | 0;
+};
+var Big_instance;
+function Big_getInstance() {
+  if (Big_instance == null)
+    new Big();
+  return Big_instance;
+}
+function Little() {
+}
+function Companion() {
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function Endian() {
+}
+protoOf(Endian).toString = function () {
+  var tmp;
+  if (this instanceof Big) {
+    tmp = 'Endian.Big';
+  } else {
+    if (this instanceof Little) {
+      tmp = 'Endian.Little';
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+  return tmp;
+};
+function _B0___init__impl__6otxhp(b0) {
+  return b0;
+}
+function _B0___get_b0__impl__g161pk($this) {
+  return $this;
+}
+//region block: init
+Companion_instance = new Companion();
+//endregion
+//region block: exports
+export {
+  Big_getInstance as Big_getInstancez5126ban219s,
+};
+//endregion

package/cardinal-sdk-ts.d.mts

@@ -18,8 +18,8 @@ export declare interface Challenge {
     readonly salts: Array<string>;
     readonly difficultyFactor: number;
 }
-export declare function resolveChallenge(config: Challenge, serializedInput: string, cryptoService?: Nullable<crypto.XCryptoService>, onProgress?: (p0: number) => void): Promise<Solution>;
-export declare function validateSolution(config: Challenge, result: Solution, serializedInput: string, cryptoService?: Nullable<crypto.XCryptoService>): Promise<boolean>;
+export declare function resolveChallenge(config: Challenge, serializedInput: string, cryptoService?: Nullable<crypto.PartialXCryptoService>, onProgress?: (p0: number) => void): Promise<Solution>;
+export declare function validateSolution(config: Challenge, result: Solution, serializedInput: string, cryptoService?: Nullable<crypto.PartialXCryptoService>): Promise<boolean>;
 export declare interface Solution {
     readonly id: string;
     readonly nonces: Array<string>;