@wireapp/core-crypto 10.0.0-pre.10 → 10.0.0-pre.11

package/dist/native/corecrypto.d.ts

@@ -41,6 +41,52 @@ export declare function setMaxLogLevel(level: CoreCryptoLogLevel): void;
  * The version of `core-crypto`.
  */
 export declare function version(): string;
+type UuidLike = Uuid;
+/**
+ * A Uuid.
+ */
+export declare class Uuid extends UniffiAbstractObject {
+	readonly [uniffiTypeNameSymbol] = "Uuid";
+	readonly [destructorGuardSymbol]: UniffiGcObject;
+	readonly [pointerLiteralSymbol]: UniffiHandle;
+	/**
+	 * Parse a `Uuid` from a string.
+	 */
+	constructor(uuid: string);
+	equals(other: Uuid): boolean;
+	hashCode(): bigint;
+	uniffiDestroy(): void;
+	static instanceOf(obj_: any): obj_ is Uuid;
+}
+type DeviceIdLike = DeviceId;
+/**
+ * A Device ID.
+ */
+export declare class DeviceId extends UniffiAbstractObject {
+	readonly [uniffiTypeNameSymbol] = "DeviceId";
+	readonly [destructorGuardSymbol]: UniffiGcObject;
+	readonly [pointerLiteralSymbol]: UniffiHandle;
+	/**
+	 * New device id from an unsigned 64-bit integer.
+	 */
+	constructor(id: bigint);
+	/**
+	 * Construct a `DeviceId` from 8 bytes encoded as a hex string.
+	 */
+	static fromHexString(hexString: string): DeviceIdLike;
+	/**
+	 * Encode the `DeviceId` as a 16-character lowercase hex string, with leading 0s.
+	 */
+	toHexString(): string;
+	/**
+	 * Get the number corresponding to this `DeviceId`.
+	 */
+	toU64(): bigint;
+	equals(other: DeviceId): boolean;
+	hashCode(): bigint;
+	uniffiDestroy(): void;
+	static instanceOf(obj_: any): obj_ is DeviceId;
+}
 /**
  * This directly represents a `ClientId` of the `<userid>-<device-id>@<domain>` format.
  * Instantiate via [ClientId::deserialize].
@@ -51,13 +97,13 @@ export type DeserializedClientId = {
 	 */
 	clientId: ClientIdLike;
 	/**
-	 * The string representation of a UUID
+	 * The user id component
 	 */
-	userId: string;
+	userId: UuidLike;
 	/**
-	 * A hex-encoded unsigned 64-bit integer
+	 * The device id component
 	 */
-	deviceId: string;
+	deviceId: DeviceIdLike;
 	/**
 	 * The domain
 	 */
@@ -86,13 +132,13 @@ export declare class ClientId extends UniffiAbstractObject {
 	/**
 	 * Create a new client id.
 	 */
-	constructor(userId: string, deviceId: string, domain: string);
+	constructor(userId: UuidLike, deviceId: DeviceIdLike, domain: string);
 	/**
 	 * Copy the wrapped data into a new byte array.
 	 */
 	copyBytes(): Uint8Array;
 	/**
-	 * Copy the wrapped data into a direct representation of the `<userid>-<device-id>@<domain>` format.
+	 * Copy the wrapped data into a direct representation of the `<user-id>:<device-id>@<domain>` format.
 	 */
 	deserialize(): DeserializedClientId;
 	equals(other: ClientId): boolean;
@@ -3091,9 +3137,9 @@ declare class CoreCryptoContext extends UniffiAbstractObject {
 	/**
 	 * Returns the E2EI identity claims for the specified users in the given conversation, grouped by user ID.
 	 */
-	getUserIdentities(conversationId: ConversationIdLike, userIds: Array<string>, asyncOpts_?: {
+	getUserIdentities(conversationId: ConversationIdLike, userIds: Array<UuidLike>, asyncOpts_?: {
 		signal: AbortSignal;
-	}): Promise<Map<string, Array<WireIdentity>>>;
+	}): Promise<Map<UuidLike, Array<WireIdentity>>>;
 	/**
 	 * Joins an existing conversation by constructing an external commit from the given group info.
 	 */
@@ -3480,9 +3526,9 @@ declare class CoreCryptoFfi extends UniffiAbstractObject {
 	/**
 	 * Returns the E2EI identity claims for the specified users in the given conversation, grouped by user ID.
 	 */
-	getUserIdentities(conversationId: ConversationIdLike, userIds: Array<string>, asyncOpts_?: {
+	getUserIdentities(conversationId: ConversationIdLike, userIds: Array<UuidLike>, asyncOpts_?: {
 		signal: AbortSignal;
-	}): Promise<Map<string, Array<WireIdentity>>>;
+	}): Promise<Map<UuidLike, Array<WireIdentity>>>;
 	/**
 	 * Returns true if history sharing is currently enabled for the given conversation.
 	 */

package/dist/native/corecrypto.js

@@ -396,6 +396,16 @@ var DEFINITIONS = {
       ret: FfiType.Void,
       hasRustCallStatus: true
     },
+    uniffi_core_crypto_ffi_fn_clone_deviceid: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_free_deviceid: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
     uniffi_core_crypto_ffi_fn_clone_epochobserver: {
       args: [FfiType.Handle],
       ret: FfiType.Handle,
@@ -496,6 +506,16 @@ var DEFINITIONS = {
       ret: FfiType.Void,
       hasRustCallStatus: true
     },
+    uniffi_core_crypto_ffi_fn_clone_uuid: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_free_uuid: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
     uniffi_core_crypto_ffi_fn_clone_welcome: {
       args: [FfiType.Handle],
       ret: FfiType.Handle,
@@ -614,7 +634,7 @@ var DEFINITIONS = {
       hasRustCallStatus: true
     },
     uniffi_core_crypto_ffi_fn_constructor_clientid_new: {
-      args: [FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
+      args: [FfiType.Handle, FfiType.Handle, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: true
     },
@@ -1195,6 +1215,41 @@ var DEFINITIONS = {
       ret: FfiType.Int8,
       hasRustCallStatus: true
     },
+    uniffi_core_crypto_ffi_fn_constructor_deviceid_from_hex_string: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_constructor_deviceid_new: {
+      args: [FfiType.UInt64],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_deviceid_to_hex_string: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_deviceid_to_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt64,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_eq_eq: {
+      args: [FfiType.Handle, FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_eq_ne: {
+      args: [FfiType.Handle, FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_hash: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt64,
+      hasRustCallStatus: true
+    },
     uniffi_core_crypto_ffi_fn_method_epochobserver_epoch_changed: {
       args: [FfiType.Handle, FfiType.Handle, FfiType.UInt64],
       ret: FfiType.Handle,
@@ -1367,6 +1422,26 @@ var DEFINITIONS = {
       ret: FfiType.UInt64,
       hasRustCallStatus: true
     },
+    uniffi_core_crypto_ffi_fn_constructor_uuid_new: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_eq_eq: {
+      args: [FfiType.Handle, FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_eq_ne: {
+      args: [FfiType.Handle, FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_hash: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt64,
+      hasRustCallStatus: true
+    },
     uniffi_core_crypto_ffi_fn_constructor_welcome_new: {
       args: [FfiType.RustBuffer],
       ret: FfiType.Handle,
@@ -1967,6 +2042,26 @@ var DEFINITIONS = {
       ret: FfiType.UInt16,
       hasRustCallStatus: false
     },
+    uniffi_core_crypto_ffi_checksum_constructor_deviceid_from_hex_string: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_core_crypto_ffi_checksum_constructor_deviceid_new: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_core_crypto_ffi_checksum_method_deviceid_to_hex_string: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_core_crypto_ffi_checksum_method_deviceid_to_u64: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
     uniffi_core_crypto_ffi_checksum_method_epochobserver_epoch_changed: {
       args: [],
       ret: FfiType.UInt16,
@@ -2097,6 +2192,11 @@ var DEFINITIONS = {
       ret: FfiType.UInt16,
       hasRustCallStatus: false
     },
+    uniffi_core_crypto_ffi_checksum_constructor_uuid_new: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
     uniffi_core_crypto_ffi_checksum_constructor_welcome_new: {
       args: [],
       ret: FfiType.UInt16,
@@ -2585,6 +2685,90 @@ function version() {
     return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_func_version(callStatus);
   }, FfiConverterString.lift.bind(FfiConverterString)));
 }
+
+class Uuid extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "Uuid";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(uuid) {
+    super();
+    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_uuid_new(FfiConverterString.lower(uuid, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeUuidObjectFactory.bless(pointer);
+  }
+  equals(other) {
+    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_eq_eq(uniffiTypeUuidObjectFactory.clonePointer(this), FfiConverterTypeUuid.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  hashCode() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_hash(uniffiTypeUuidObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeUuidObjectFactory.pointer(this);
+      uniffiTypeUuidObjectFactory.freePointer(pointer);
+      uniffiTypeUuidObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeUuidObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeUuidObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeUuidObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(Uuid.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Uuid";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_uuid(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_uuid(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Uuid";
+    }
+  };
+})();
+var FfiConverterTypeUuid = new FfiConverterObject(uniffiTypeUuidObjectFactory);
 var stringConverter = (() => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
@@ -2600,6 +2784,111 @@ var stringConverter = (() => {
   };
 })();
 var FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+class DeviceId extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "DeviceId";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(id) {
+    super();
+    const pointer = uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_new(FfiConverterUInt64.lower(id, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeDeviceIdObjectFactory.bless(pointer);
+  }
+  static fromHexString(hexString) {
+    return FfiConverterTypeDeviceId.lift(uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_from_hex_string(FfiConverterString.lower(hexString, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  toHexString() {
+    return ((__rb) => {
+      try {
+        return FfiConverterString.lift(__rb);
+      } finally {
+        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
+      }
+    })(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_hex_string(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  toU64() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_u64(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  equals(other) {
+    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_eq_eq(uniffiTypeDeviceIdObjectFactory.clonePointer(this), FfiConverterTypeDeviceId.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  hashCode() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_hash(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeDeviceIdObjectFactory.pointer(this);
+      uniffiTypeDeviceIdObjectFactory.freePointer(pointer);
+      uniffiTypeDeviceIdObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeDeviceIdObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeDeviceIdObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeDeviceIdObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(DeviceId.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "DeviceId";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_deviceid(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_deviceid(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "DeviceId";
+    }
+  };
+})();
+var FfiConverterTypeDeviceId = new FfiConverterObject(uniffiTypeDeviceIdObjectFactory);
 var DeserializedClientId = (() => {
   const defaults = () => ({});
   const create = (() => {
@@ -2617,19 +2906,19 @@ var FfiConverterTypeDeserializedClientId = (() => {
     read(from) {
       return {
         clientId: FfiConverterTypeClientId.read(from),
-        userId: FfiConverterString.read(from),
-        deviceId: FfiConverterString.read(from),
+        userId: FfiConverterTypeUuid.read(from),
+        deviceId: FfiConverterTypeDeviceId.read(from),
         domain: FfiConverterString.read(from)
       };
     }
     write(value, into) {
       FfiConverterTypeClientId.write(value.clientId, into);
-      FfiConverterString.write(value.userId, into);
-      FfiConverterString.write(value.deviceId, into);
+      FfiConverterTypeUuid.write(value.userId, into);
+      FfiConverterTypeDeviceId.write(value.deviceId, into);
       FfiConverterString.write(value.domain, into);
     }
     allocationSize(value) {
-      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterString.allocationSize(value.userId) + FfiConverterString.allocationSize(value.deviceId) + FfiConverterString.allocationSize(value.domain);
+      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterTypeUuid.allocationSize(value.userId) + FfiConverterTypeDeviceId.allocationSize(value.deviceId) + FfiConverterString.allocationSize(value.domain);
     }
   }
   return new FFIConverter;
@@ -2641,8 +2930,8 @@ class ClientId extends UniffiAbstractObject {
   [pointerLiteralSymbol];
   constructor(userId, deviceId, domain) {
     super();
-    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_clientid_new(FfiConverterString.lower(userId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterString.lower(deviceId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterString.lower(domain, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    const pointer = uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_clientid_new(FfiConverterTypeUuid.lower(userId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterTypeDeviceId.lower(deviceId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterString.lower(domain, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
     }, FfiConverterString.lift.bind(FfiConverterString));
     this[pointerLiteralSymbol] = pointer;
     this[destructorGuardSymbol] = uniffiTypeClientIdObjectFactory.bless(pointer);
@@ -6069,8 +6358,8 @@ class CoreCryptoContext extends UniffiAbstractObject {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(uniffiCaller, () => {
-        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_corecryptocontext_get_user_identities(uniffiTypeCoreCryptoContextObjectFactory.clonePointer(this), FfiConverterTypeConversationId.lower(conversationId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterSequenceString.lower(userIds, core_crypto_ffi_ffi_default().rustbuffer_alloc));
-      }, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_poll_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_cancel_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_complete_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_free_rust_buffer, FfiConverterMapStringSequenceTypeWireIdentity.lift.bind(FfiConverterMapStringSequenceTypeWireIdentity), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError));
+        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_corecryptocontext_get_user_identities(uniffiTypeCoreCryptoContextObjectFactory.clonePointer(this), FfiConverterTypeConversationId.lower(conversationId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterSequenceTypeUuid.lower(userIds, core_crypto_ffi_ffi_default().rustbuffer_alloc));
+      }, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_poll_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_cancel_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_complete_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_free_rust_buffer, FfiConverterMapTypeUuidSequenceTypeWireIdentity.lift.bind(FfiConverterMapTypeUuidSequenceTypeWireIdentity), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError));
     } catch (__error) {
       if (uniffiIsDebug && __error instanceof Error) {
         __error.stack = __stack;
@@ -7157,8 +7446,8 @@ class CoreCryptoFfi extends UniffiAbstractObject {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(uniffiCaller, () => {
-        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_corecryptoffi_get_user_identities(uniffiTypeCoreCryptoFfiObjectFactory.clonePointer(this), FfiConverterTypeConversationId.lower(conversationId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterSequenceString.lower(userIds, core_crypto_ffi_ffi_default().rustbuffer_alloc));
-      }, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_poll_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_cancel_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_complete_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_free_rust_buffer, FfiConverterMapStringSequenceTypeWireIdentity.lift.bind(FfiConverterMapStringSequenceTypeWireIdentity), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError));
+        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_corecryptoffi_get_user_identities(uniffiTypeCoreCryptoFfiObjectFactory.clonePointer(this), FfiConverterTypeConversationId.lower(conversationId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterSequenceTypeUuid.lower(userIds, core_crypto_ffi_ffi_default().rustbuffer_alloc));
+      }, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_poll_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_cancel_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_complete_rust_buffer, core_crypto_ffi_ffi_default().ffi_core_crypto_ffi_rust_future_free_rust_buffer, FfiConverterMapTypeUuidSequenceTypeWireIdentity.lift.bind(FfiConverterMapTypeUuidSequenceTypeWireIdentity), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError));
     } catch (__error) {
       if (uniffiIsDebug && __error instanceof Error) {
         __error.stack = __stack;
@@ -8011,8 +8300,9 @@ var FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration
 var FfiConverterSequenceTypeClientId = new FfiConverterArray(FfiConverterTypeClientId);
 var FfiConverterSequenceTypeWireIdentity = new FfiConverterArray(FfiConverterTypeWireIdentity);
 var FfiConverterSequenceTypeKeyPackageRef = new FfiConverterArray(FfiConverterTypeKeyPackageRef);
+var FfiConverterSequenceTypeUuid = new FfiConverterArray(FfiConverterTypeUuid);
+var FfiConverterMapTypeUuidSequenceTypeWireIdentity = new FfiConverterMap(FfiConverterTypeUuid, FfiConverterSequenceTypeWireIdentity);
 var FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
-var FfiConverterMapStringSequenceTypeWireIdentity = new FfiConverterMap(FfiConverterString, FfiConverterSequenceTypeWireIdentity);
 var FfiConverterMapStringBytes = new FfiConverterMap(FfiConverterString, FfiConverterUint8Array);
 var FfiConverterOptionalTypeCipherSuite = new FfiConverterOptional(FfiConverterTypeCipherSuite);
 var FfiConverterOptionalTypeCredentialType = new FfiConverterOptional(FfiConverterTypeCredentialType);
@@ -8058,13 +8348,13 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_func_version() !== 8474) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_func_version");
   }
-  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_clientid_new() !== 24154) {
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_clientid_new() !== 44879) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_clientid_new");
   }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_clientid_copy_bytes() !== 10155) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_clientid_copy_bytes");
   }
-  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_clientid_deserialize() !== 28989) {
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_clientid_deserialize() !== 19701) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_clientid_deserialize");
   }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_conversationid_new() !== 12558) {
@@ -8145,7 +8435,7 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_get_key_packages() !== 64486) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptocontext_get_key_packages");
   }
-  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_get_user_identities() !== 55318) {
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_get_user_identities() !== 21557) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptocontext_get_user_identities");
   }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_join_by_external_commit() !== 38654) {
@@ -8277,7 +8567,7 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptoffi_get_pki_environment() !== 28140) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptoffi_get_pki_environment");
   }
-  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptoffi_get_user_identities() !== 64461) {
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptoffi_get_user_identities() !== 33184) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptoffi_get_user_identities");
   }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptoffi_is_history_sharing_enabled() !== 59378) {
@@ -8361,6 +8651,18 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_databasekey_new() !== 36198) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_databasekey_new");
   }
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_deviceid_from_hex_string() !== 44184) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_deviceid_from_hex_string");
+  }
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_deviceid_new() !== 62163) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_deviceid_new");
+  }
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_deviceid_to_hex_string() !== 17498) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_deviceid_to_hex_string");
+  }
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_deviceid_to_u64() !== 14542) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_deviceid_to_u64");
+  }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_epochobserver_epoch_changed() !== 64106) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_epochobserver_epoch_changed");
   }
@@ -8439,6 +8741,9 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_secretkey_copy_bytes() !== 18148) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_secretkey_copy_bytes");
   }
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_uuid_new() !== 40259) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_uuid_new");
+  }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_constructor_welcome_new() !== 20256) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_constructor_welcome_new");
   }
@@ -8486,6 +8791,7 @@ var core_crypto_ffi_default = Object.freeze({
     FfiConverterTypeDatabaseKey,
     FfiConverterTypeDecryptedMessage,
     FfiConverterTypeDeserializedClientId,
+    FfiConverterTypeDeviceId,
     FfiConverterTypeDeviceStatus,
     FfiConverterTypeE2eiConversationState,
     FfiConverterTypeEpochChangedReportingError,
@@ -8516,6 +8822,7 @@ var core_crypto_ffi_default = Object.freeze({
     FfiConverterTypeSecretKey,
     FfiConverterTypeSignatureScheme,
     FfiConverterTypeTimestamp,
+    FfiConverterTypeUuid,
     FfiConverterTypeWelcome,
     FfiConverterTypeWireIdentity,
     FfiConverterTypeX509CredentialAcquisition,
@@ -8616,6 +8923,7 @@ export {
   X509CredentialAcquisition2 as X509CredentialAcquisition,
   WireIdentity,
   Welcome,
+  Uuid,
   SignatureScheme,
   SecretKey,
   MlsRatchetTreeType as RatchetTreeType,
@@ -8642,6 +8950,7 @@ export {
   EpochChangedReportingError,
   E2eiConversationState,
   DeviceStatus,
+  DeviceId,
   DeserializedClientId,
   DatabaseKey,
   Database,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wireapp/core-crypto",
-    "version": "10.0.0-pre.10",
+    "version": "10.0.0-pre.11",
     "author": "Wire CoreCrypto team <team.corecrypto@wire.com>",
     "repository": {
         "type": "git",