tfhe 0.3.1 → 0.4.0

package/tfhe.d.ts

@@ -324,38 +324,49 @@ export class BooleanPublicKey {
 }
 /**
 */
-export class CompactFheUint128 {
+export class CompactFheInt128 {
   free(): void;
 /**
 * @param {any} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint128}
+* @returns {CompactFheInt128}
 */
-  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheUint128;
+  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheInt128;
 /**
-* @returns {FheUint128}
+* @returns {FheInt128}
 */
-  expand(): FheUint128;
+  expand(): FheInt128;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint128}
+* @returns {CompactFheInt128}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint128;
+  static deserialize(buffer: Uint8Array): CompactFheInt128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt128;
 }
 /**
 */
-export class CompactFheUint128List {
+export class CompactFheInt128List {
   free(): void;
 /**
 * @param {any[]} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint128List}
+* @returns {CompactFheInt128List}
 */
-  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheUint128List;
+  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheInt128List;
 /**
 * @returns {any[]}
 */
@@ -366,44 +377,55 @@ export class CompactFheUint128List {
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint128List}
+* @returns {CompactFheInt128List}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint128List;
+  static deserialize(buffer: Uint8Array): CompactFheInt128List;
 }
 /**
 */
-export class CompactFheUint16 {
+export class CompactFheInt16 {
   free(): void;
 /**
 * @param {number} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint16}
+* @returns {CompactFheInt16}
 */
-  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint16;
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheInt16;
 /**
-* @returns {FheUint16}
+* @returns {FheInt16}
 */
-  expand(): FheUint16;
+  expand(): FheInt16;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint16}
+* @returns {CompactFheInt16}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint16;
+  static deserialize(buffer: Uint8Array): CompactFheInt16;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt16}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt16;
 }
 /**
 */
-export class CompactFheUint16List {
+export class CompactFheInt16List {
   free(): void;
 /**
-* @param {Uint16Array} values
+* @param {Int16Array} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint16List}
+* @returns {CompactFheInt16List}
 */
-  static encrypt_with_compact_public_key(values: Uint16Array, public_key: TfheCompactPublicKey): CompactFheUint16List;
+  static encrypt_with_compact_public_key(values: Int16Array, public_key: TfheCompactPublicKey): CompactFheInt16List;
 /**
 * @returns {any[]}
 */
@@ -414,44 +436,55 @@ export class CompactFheUint16List {
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint16List}
+* @returns {CompactFheInt16List}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint16List;
+  static deserialize(buffer: Uint8Array): CompactFheInt16List;
 }
 /**
 */
-export class CompactFheUint256 {
+export class CompactFheInt256 {
   free(): void;
 /**
 * @param {any} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint256}
+* @returns {CompactFheInt256}
 */
-  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheUint256;
+  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheInt256;
 /**
-* @returns {FheUint256}
+* @returns {FheInt256}
 */
-  expand(): FheUint256;
+  expand(): FheInt256;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint256}
+* @returns {CompactFheInt256}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint256;
+  static deserialize(buffer: Uint8Array): CompactFheInt256;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt256}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt256;
 }
 /**
 */
-export class CompactFheUint256List {
+export class CompactFheInt256List {
   free(): void;
 /**
 * @param {any[]} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint256List}
+* @returns {CompactFheInt256List}
 */
-  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheUint256List;
+  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheInt256List;
 /**
 * @returns {any[]}
 */
@@ -462,44 +495,55 @@ export class CompactFheUint256List {
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint256List}
+* @returns {CompactFheInt256List}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint256List;
+  static deserialize(buffer: Uint8Array): CompactFheInt256List;
 }
 /**
 */
-export class CompactFheUint32 {
+export class CompactFheInt32 {
   free(): void;
 /**
 * @param {number} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint32}
+* @returns {CompactFheInt32}
 */
-  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint32;
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheInt32;
 /**
-* @returns {FheUint32}
+* @returns {FheInt32}
 */
-  expand(): FheUint32;
+  expand(): FheInt32;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint32}
+* @returns {CompactFheInt32}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint32;
+  static deserialize(buffer: Uint8Array): CompactFheInt32;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt32}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt32;
 }
 /**
 */
-export class CompactFheUint32List {
+export class CompactFheInt32List {
   free(): void;
 /**
-* @param {Uint32Array} values
+* @param {Int32Array} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint32List}
+* @returns {CompactFheInt32List}
 */
-  static encrypt_with_compact_public_key(values: Uint32Array, public_key: TfheCompactPublicKey): CompactFheUint32List;
+  static encrypt_with_compact_public_key(values: Int32Array, public_key: TfheCompactPublicKey): CompactFheInt32List;
 /**
 * @returns {any[]}
 */
@@ -510,44 +554,55 @@ export class CompactFheUint32List {
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint32List}
+* @returns {CompactFheInt32List}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint32List;
+  static deserialize(buffer: Uint8Array): CompactFheInt32List;
 }
 /**
 */
-export class CompactFheUint64 {
+export class CompactFheInt64 {
   free(): void;
 /**
 * @param {bigint} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint64}
+* @returns {CompactFheInt64}
 */
-  static encrypt_with_compact_public_key(value: bigint, client_key: TfheCompactPublicKey): CompactFheUint64;
+  static encrypt_with_compact_public_key(value: bigint, client_key: TfheCompactPublicKey): CompactFheInt64;
 /**
-* @returns {FheUint64}
+* @returns {FheInt64}
 */
-  expand(): FheUint64;
+  expand(): FheInt64;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint64}
+* @returns {CompactFheInt64}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint64;
+  static deserialize(buffer: Uint8Array): CompactFheInt64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt64;
 }
 /**
 */
-export class CompactFheUint64List {
+export class CompactFheInt64List {
   free(): void;
 /**
-* @param {BigUint64Array} values
+* @param {BigInt64Array} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint64List}
+* @returns {CompactFheInt64List}
 */
-  static encrypt_with_compact_public_key(values: BigUint64Array, public_key: TfheCompactPublicKey): CompactFheUint64List;
+  static encrypt_with_compact_public_key(values: BigInt64Array, public_key: TfheCompactPublicKey): CompactFheInt64List;
 /**
 * @returns {any[]}
 */
@@ -558,201 +613,1166 @@ export class CompactFheUint64List {
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint64List}
+* @returns {CompactFheInt64List}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint64List;
+  static deserialize(buffer: Uint8Array): CompactFheInt64List;
 }
 /**
 */
-export class CompactFheUint8 {
+export class CompactFheInt8 {
   free(): void;
 /**
 * @param {number} value
 * @param {TfheCompactPublicKey} client_key
-* @returns {CompactFheUint8}
+* @returns {CompactFheInt8}
 */
-  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint8;
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheInt8;
 /**
-* @returns {FheUint8}
+* @returns {FheInt8}
 */
-  expand(): FheUint8;
+  expand(): FheInt8;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint8}
+* @returns {CompactFheInt8}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint8;
+  static deserialize(buffer: Uint8Array): CompactFheInt8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheInt8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheInt8;
 }
 /**
 */
-export class CompactFheUint8List {
+export class CompactFheInt8List {
   free(): void;
 /**
-* @param {Uint8Array} values
+* @param {Int8Array} values
 * @param {TfheCompactPublicKey} public_key
-* @returns {CompactFheUint8List}
+* @returns {CompactFheInt8List}
+*/
+  static encrypt_with_compact_public_key(values: Int8Array, public_key: TfheCompactPublicKey): CompactFheInt8List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheInt8List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheInt8List;
+}
+/**
+*/
+export class CompactFheUint128 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint128}
+*/
+  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheUint128;
+/**
+* @returns {FheUint128}
+*/
+  expand(): FheUint128;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint128}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint128;
+}
+/**
+*/
+export class CompactFheUint128List {
+  free(): void;
+/**
+* @param {any[]} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint128List}
+*/
+  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheUint128List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint128List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint128List;
+}
+/**
+*/
+export class CompactFheUint16 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint16}
+*/
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint16;
+/**
+* @returns {FheUint16}
+*/
+  expand(): FheUint16;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint16}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint16;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint16}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint16;
+}
+/**
+*/
+export class CompactFheUint16List {
+  free(): void;
+/**
+* @param {Uint16Array} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint16List}
+*/
+  static encrypt_with_compact_public_key(values: Uint16Array, public_key: TfheCompactPublicKey): CompactFheUint16List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint16List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint16List;
+}
+/**
+*/
+export class CompactFheUint256 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint256}
+*/
+  static encrypt_with_compact_public_key(value: any, client_key: TfheCompactPublicKey): CompactFheUint256;
+/**
+* @returns {FheUint256}
+*/
+  expand(): FheUint256;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint256}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint256;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint256}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint256;
+}
+/**
+*/
+export class CompactFheUint256List {
+  free(): void;
+/**
+* @param {any[]} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint256List}
+*/
+  static encrypt_with_compact_public_key(values: any[], public_key: TfheCompactPublicKey): CompactFheUint256List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint256List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint256List;
+}
+/**
+*/
+export class CompactFheUint32 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint32}
+*/
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint32;
+/**
+* @returns {FheUint32}
+*/
+  expand(): FheUint32;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint32}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint32;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint32}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint32;
+}
+/**
+*/
+export class CompactFheUint32List {
+  free(): void;
+/**
+* @param {Uint32Array} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint32List}
+*/
+  static encrypt_with_compact_public_key(values: Uint32Array, public_key: TfheCompactPublicKey): CompactFheUint32List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint32List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint32List;
+}
+/**
+*/
+export class CompactFheUint64 {
+  free(): void;
+/**
+* @param {bigint} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint64}
+*/
+  static encrypt_with_compact_public_key(value: bigint, client_key: TfheCompactPublicKey): CompactFheUint64;
+/**
+* @returns {FheUint64}
+*/
+  expand(): FheUint64;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint64}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint64;
+}
+/**
+*/
+export class CompactFheUint64List {
+  free(): void;
+/**
+* @param {BigUint64Array} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint64List}
+*/
+  static encrypt_with_compact_public_key(values: BigUint64Array, public_key: TfheCompactPublicKey): CompactFheUint64List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint64List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint64List;
+}
+/**
+*/
+export class CompactFheUint8 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheCompactPublicKey} client_key
+* @returns {CompactFheUint8}
+*/
+  static encrypt_with_compact_public_key(value: number, client_key: TfheCompactPublicKey): CompactFheUint8;
+/**
+* @returns {FheUint8}
+*/
+  expand(): FheUint8;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint8}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompactFheUint8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactFheUint8;
+}
+/**
+*/
+export class CompactFheUint8List {
+  free(): void;
+/**
+* @param {Uint8Array} values
+* @param {TfheCompactPublicKey} public_key
+* @returns {CompactFheUint8List}
+*/
+  static encrypt_with_compact_public_key(values: Uint8Array, public_key: TfheCompactPublicKey): CompactFheUint8List;
+/**
+* @returns {any[]}
+*/
+  expand(): any[];
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompactFheUint8List}
+*/
+  static deserialize(buffer: Uint8Array): CompactFheUint8List;
+}
+/**
+*/
+export class CompressedFheInt128 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt128}
+*/
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt128;
+/**
+* @returns {FheInt128}
+*/
+  decompress(): FheInt128;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt128}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt128;
+}
+/**
+*/
+export class CompressedFheInt16 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt16}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt16;
+/**
+* @returns {FheInt16}
+*/
+  decompress(): FheInt16;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt16}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt16;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt16}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt16;
+}
+/**
+*/
+export class CompressedFheInt256 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt256}
+*/
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt256;
+/**
+* @returns {FheInt256}
+*/
+  decompress(): FheInt256;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt256}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt256;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt256}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt256;
+}
+/**
+*/
+export class CompressedFheInt32 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt32}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt32;
+/**
+* @returns {FheInt32}
+*/
+  decompress(): FheInt32;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt32}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt32;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt32}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt32;
+}
+/**
+*/
+export class CompressedFheInt64 {
+  free(): void;
+/**
+* @param {bigint} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt64}
+*/
+  static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheInt64;
+/**
+* @returns {FheInt64}
+*/
+  decompress(): FheInt64;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt64}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt64;
+}
+/**
+*/
+export class CompressedFheInt8 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheInt8}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt8;
+/**
+* @returns {FheInt8}
+*/
+  decompress(): FheInt8;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheInt8}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheInt8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheInt8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt8;
+}
+/**
+*/
+export class CompressedFheUint128 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint128}
+*/
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint128;
+/**
+* @returns {FheUint128}
+*/
+  decompress(): FheUint128;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint128}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint128;
+}
+/**
+*/
+export class CompressedFheUint16 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint16}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint16;
+/**
+* @returns {FheUint16}
+*/
+  decompress(): FheUint16;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint16}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint16;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint16}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint16;
+}
+/**
+*/
+export class CompressedFheUint256 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint256}
+*/
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint256;
+/**
+* @returns {FheUint256}
+*/
+  decompress(): FheUint256;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint256}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint256;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint256}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint256;
+}
+/**
+*/
+export class CompressedFheUint32 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint32}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint32;
+/**
+* @returns {FheUint32}
+*/
+  decompress(): FheUint32;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint32}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint32;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint32}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint32;
+}
+/**
+*/
+export class CompressedFheUint64 {
+  free(): void;
+/**
+* @param {bigint} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint64}
+*/
+  static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheUint64;
+/**
+* @returns {FheUint64}
+*/
+  decompress(): FheUint64;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint64}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint64;
+}
+/**
+*/
+export class CompressedFheUint8 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {CompressedFheUint8}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint8;
+/**
+* @returns {FheUint8}
+*/
+  decompress(): FheUint8;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {CompressedFheUint8}
+*/
+  static deserialize(buffer: Uint8Array): CompressedFheUint8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {CompressedFheUint8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint8;
+}
+/**
+*/
+export class FheInt128 {
+  free(): void;
+/**
+* @param {any} value
+* @param {TfheClientKey} client_key
+* @returns {FheInt128}
+*/
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): FheInt128;
+/**
+* @param {any} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt128}
+*/
+  static encrypt_with_public_key(value: any, public_key: TfhePublicKey): FheInt128;
+/**
+* @param {any} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt128}
+*/
+  static encrypt_with_compressed_public_key(value: any, compressed_public_key: TfheCompressedPublicKey): FheInt128;
+/**
+* @param {any} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt128}
+*/
+  static encrypt_with_compact_public_key(value: any, compact_public_key: TfheCompactPublicKey): FheInt128;
+/**
+* @param {TfheClientKey} client_key
+* @returns {any}
+*/
+  decrypt(client_key: TfheClientKey): any;
+/**
+* @returns {Uint8Array}
+*/
+  serialize(): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @returns {FheInt128}
+*/
+  static deserialize(buffer: Uint8Array): FheInt128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheInt128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt128;
+}
+/**
+*/
+export class FheInt16 {
+  free(): void;
+/**
+* @param {number} value
+* @param {TfheClientKey} client_key
+* @returns {FheInt16}
+*/
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): FheInt16;
+/**
+* @param {number} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt16}
+*/
+  static encrypt_with_public_key(value: number, public_key: TfhePublicKey): FheInt16;
+/**
+* @param {number} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt16}
+*/
+  static encrypt_with_compressed_public_key(value: number, compressed_public_key: TfheCompressedPublicKey): FheInt16;
+/**
+* @param {number} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt16}
+*/
+  static encrypt_with_compact_public_key(value: number, compact_public_key: TfheCompactPublicKey): FheInt16;
+/**
+* @param {TfheClientKey} client_key
+* @returns {number}
+*/
+  decrypt(client_key: TfheClientKey): number;
+/**
+* @returns {Uint8Array}
 */
-  static encrypt_with_compact_public_key(values: Uint8Array, public_key: TfheCompactPublicKey): CompactFheUint8List;
+  serialize(): Uint8Array;
 /**
-* @returns {any[]}
+* @param {Uint8Array} buffer
+* @returns {FheInt16}
 */
-  expand(): any[];
+  static deserialize(buffer: Uint8Array): FheInt16;
 /**
+* @param {bigint} serialized_size_limit
 * @returns {Uint8Array}
 */
-  serialize(): Uint8Array;
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompactFheUint8List}
+* @param {bigint} serialized_size_limit
+* @returns {FheInt16}
 */
-  static deserialize(buffer: Uint8Array): CompactFheUint8List;
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt16;
 }
 /**
 */
-export class CompressedFheUint128 {
+export class FheInt256 {
   free(): void;
 /**
 * @param {any} value
 * @param {TfheClientKey} client_key
-* @returns {CompressedFheUint128}
+* @returns {FheInt256}
 */
-  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint128;
+  static encrypt_with_client_key(value: any, client_key: TfheClientKey): FheInt256;
 /**
-* @returns {FheUint128}
+* @param {any} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt256}
 */
-  decompress(): FheUint128;
+  static encrypt_with_public_key(value: any, public_key: TfhePublicKey): FheInt256;
 /**
-* @returns {Uint8Array}
+* @param {any} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt256}
 */
-  serialize(): Uint8Array;
+  static encrypt_with_compressed_public_key(value: any, compressed_public_key: TfheCompressedPublicKey): FheInt256;
 /**
-* @param {Uint8Array} buffer
-* @returns {CompressedFheUint128}
+* @param {any} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt256}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint128;
-}
+  static encrypt_with_compact_public_key(value: any, compact_public_key: TfheCompactPublicKey): FheInt256;
 /**
+* @param {TfheClientKey} client_key
+* @returns {any}
 */
-export class CompressedFheUint16 {
-  free(): void;
+  decrypt(client_key: TfheClientKey): any;
 /**
-* @param {number} value
-* @param {TfheClientKey} client_key
-* @returns {CompressedFheUint16}
+* @returns {Uint8Array}
 */
-  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint16;
+  serialize(): Uint8Array;
 /**
-* @returns {FheUint16}
+* @param {Uint8Array} buffer
+* @returns {FheInt256}
 */
-  decompress(): FheUint16;
+  static deserialize(buffer: Uint8Array): FheInt256;
 /**
+* @param {bigint} serialized_size_limit
 * @returns {Uint8Array}
 */
-  serialize(): Uint8Array;
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompressedFheUint16}
+* @param {bigint} serialized_size_limit
+* @returns {FheInt256}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint16;
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt256;
 }
 /**
 */
-export class CompressedFheUint256 {
+export class FheInt32 {
   free(): void;
 /**
-* @param {any} value
+* @param {number} value
 * @param {TfheClientKey} client_key
-* @returns {CompressedFheUint256}
+* @returns {FheInt32}
 */
-  static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint256;
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): FheInt32;
 /**
-* @returns {FheUint256}
+* @param {number} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt32}
 */
-  decompress(): FheUint256;
+  static encrypt_with_public_key(value: number, public_key: TfhePublicKey): FheInt32;
 /**
-* @returns {Uint8Array}
+* @param {number} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt32}
 */
-  serialize(): Uint8Array;
+  static encrypt_with_compressed_public_key(value: number, compressed_public_key: TfheCompressedPublicKey): FheInt32;
 /**
-* @param {Uint8Array} buffer
-* @returns {CompressedFheUint256}
+* @param {number} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt32}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint256;
-}
+  static encrypt_with_compact_public_key(value: number, compact_public_key: TfheCompactPublicKey): FheInt32;
 /**
+* @param {TfheClientKey} client_key
+* @returns {number}
 */
-export class CompressedFheUint32 {
-  free(): void;
+  decrypt(client_key: TfheClientKey): number;
 /**
-* @param {number} value
-* @param {TfheClientKey} client_key
-* @returns {CompressedFheUint32}
+* @returns {Uint8Array}
 */
-  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint32;
+  serialize(): Uint8Array;
 /**
-* @returns {FheUint32}
+* @param {Uint8Array} buffer
+* @returns {FheInt32}
 */
-  decompress(): FheUint32;
+  static deserialize(buffer: Uint8Array): FheInt32;
 /**
+* @param {bigint} serialized_size_limit
 * @returns {Uint8Array}
 */
-  serialize(): Uint8Array;
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompressedFheUint32}
+* @param {bigint} serialized_size_limit
+* @returns {FheInt32}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint32;
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt32;
 }
 /**
 */
-export class CompressedFheUint64 {
+export class FheInt64 {
   free(): void;
 /**
 * @param {bigint} value
 * @param {TfheClientKey} client_key
-* @returns {CompressedFheUint64}
+* @returns {FheInt64}
 */
-  static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheUint64;
+  static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): FheInt64;
 /**
-* @returns {FheUint64}
+* @param {bigint} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt64}
 */
-  decompress(): FheUint64;
+  static encrypt_with_public_key(value: bigint, public_key: TfhePublicKey): FheInt64;
+/**
+* @param {bigint} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt64}
+*/
+  static encrypt_with_compressed_public_key(value: bigint, compressed_public_key: TfheCompressedPublicKey): FheInt64;
+/**
+* @param {bigint} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt64}
+*/
+  static encrypt_with_compact_public_key(value: bigint, compact_public_key: TfheCompactPublicKey): FheInt64;
+/**
+* @param {TfheClientKey} client_key
+* @returns {bigint}
+*/
+  decrypt(client_key: TfheClientKey): bigint;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompressedFheUint64}
+* @returns {FheInt64}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint64;
+  static deserialize(buffer: Uint8Array): FheInt64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheInt64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt64;
 }
 /**
 */
-export class CompressedFheUint8 {
+export class FheInt8 {
   free(): void;
 /**
 * @param {number} value
 * @param {TfheClientKey} client_key
-* @returns {CompressedFheUint8}
+* @returns {FheInt8}
 */
-  static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint8;
+  static encrypt_with_client_key(value: number, client_key: TfheClientKey): FheInt8;
 /**
-* @returns {FheUint8}
+* @param {number} value
+* @param {TfhePublicKey} public_key
+* @returns {FheInt8}
 */
-  decompress(): FheUint8;
+  static encrypt_with_public_key(value: number, public_key: TfhePublicKey): FheInt8;
+/**
+* @param {number} value
+* @param {TfheCompressedPublicKey} compressed_public_key
+* @returns {FheInt8}
+*/
+  static encrypt_with_compressed_public_key(value: number, compressed_public_key: TfheCompressedPublicKey): FheInt8;
+/**
+* @param {number} value
+* @param {TfheCompactPublicKey} compact_public_key
+* @returns {FheInt8}
+*/
+  static encrypt_with_compact_public_key(value: number, compact_public_key: TfheCompactPublicKey): FheInt8;
+/**
+* @param {TfheClientKey} client_key
+* @returns {number}
+*/
+  decrypt(client_key: TfheClientKey): number;
 /**
 * @returns {Uint8Array}
 */
   serialize(): Uint8Array;
 /**
 * @param {Uint8Array} buffer
-* @returns {CompressedFheUint8}
+* @returns {FheInt8}
 */
-  static deserialize(buffer: Uint8Array): CompressedFheUint8;
+  static deserialize(buffer: Uint8Array): FheInt8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheInt8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheInt8;
 }
 /**
 */
@@ -796,6 +1816,17 @@ export class FheUint128 {
 * @returns {FheUint128}
 */
   static deserialize(buffer: Uint8Array): FheUint128;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint128}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint128;
 }
 /**
 */
@@ -839,6 +1870,17 @@ export class FheUint16 {
 * @returns {FheUint16}
 */
   static deserialize(buffer: Uint8Array): FheUint16;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint16}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint16;
 }
 /**
 */
@@ -882,6 +1924,17 @@ export class FheUint256 {
 * @returns {FheUint256}
 */
   static deserialize(buffer: Uint8Array): FheUint256;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint256}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint256;
 }
 /**
 */
@@ -925,6 +1978,17 @@ export class FheUint32 {
 * @returns {FheUint32}
 */
   static deserialize(buffer: Uint8Array): FheUint32;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint32}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint32;
 }
 /**
 */
@@ -968,6 +2032,17 @@ export class FheUint64 {
 * @returns {FheUint64}
 */
   static deserialize(buffer: Uint8Array): FheUint64;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint64}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint64;
 }
 /**
 */
@@ -1011,6 +2086,17 @@ export class FheUint8 {
 * @returns {FheUint8}
 */
   static deserialize(buffer: Uint8Array): FheUint8;
+/**
+* @param {bigint} serialized_size_limit
+* @returns {Uint8Array}
+*/
+  safe_serialize(serialized_size_limit: bigint): Uint8Array;
+/**
+* @param {Uint8Array} buffer
+* @param {bigint} serialized_size_limit
+* @returns {FheUint8}
+*/
+  static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): FheUint8;
 }
 /**
 */
@@ -1376,6 +2462,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_tfhe_free: (a: number) => void;
   readonly __wbg_booleanciphertext_free: (a: number) => void;
   readonly __wbg_booleancompressedciphertext_free: (a: number) => void;
   readonly __wbg_booleanclientkey_free: (a: number) => void;
@@ -1405,8 +2492,6 @@ export interface InitOutput {
   readonly boolean_serialize_compressed_server_key: (a: number, b: number) => void;
   readonly boolean_deserialize_compressed_server_key: (a: number, b: number, c: number) => void;
   readonly __wbg_boolean_free: (a: number) => void;
-  readonly __wbg_tfhe_free: (a: number) => void;
-  readonly __wbg_fheuint128_free: (a: number) => void;
   readonly fheuint128_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly fheuint128_encrypt_with_public_key: (a: number, b: number, c: number) => void;
   readonly fheuint128_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
@@ -1414,16 +2499,19 @@ export interface InitOutput {
   readonly fheuint128_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint128_serialize: (a: number, b: number) => void;
   readonly fheuint128_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_compressedfheuint128_free: (a: number) => void;
+  readonly fheuint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint128_encrypt_with_client_key: (a: number, b: number, c: number) => void;
-  readonly compressedfheuint128_decompress: (a: number, b: number) => void;
   readonly compressedfheuint128_serialize: (a: number, b: number) => void;
   readonly compressedfheuint128_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_compactfheuint128_free: (a: number) => void;
+  readonly compressedfheuint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint128_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint128_expand: (a: number, b: number) => void;
   readonly compactfheuint128_serialize: (a: number, b: number) => void;
   readonly compactfheuint128_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint128list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint128list_expand: (a: number, b: number) => void;
   readonly compactfheuint128list_serialize: (a: number, b: number) => void;
@@ -1435,17 +2523,75 @@ export interface InitOutput {
   readonly fheuint256_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint256_serialize: (a: number, b: number) => void;
   readonly fheuint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheuint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint256_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly compressedfheuint256_serialize: (a: number, b: number) => void;
   readonly compressedfheuint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint256_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint256_expand: (a: number, b: number) => void;
   readonly compactfheuint256_serialize: (a: number, b: number) => void;
   readonly compactfheuint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint256list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint256list_expand: (a: number, b: number) => void;
   readonly compactfheuint256list_serialize: (a: number, b: number) => void;
   readonly compactfheuint256list_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_fheint128_free: (a: number) => void;
+  readonly fheint128_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint128_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint128_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint128_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint128_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint128_serialize: (a: number, b: number) => void;
+  readonly fheint128_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_compressedfheint128_free: (a: number) => void;
+  readonly compressedfheint128_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint128_decompress: (a: number, b: number) => void;
+  readonly compressedfheint128_serialize: (a: number, b: number) => void;
+  readonly compressedfheint128_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_compactfheint128_free: (a: number) => void;
+  readonly compactfheint128_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint128_expand: (a: number, b: number) => void;
+  readonly compactfheint128_serialize: (a: number, b: number) => void;
+  readonly compactfheint128_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint128_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint128_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint128list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint128list_expand: (a: number, b: number) => void;
+  readonly compactfheint128list_serialize: (a: number, b: number) => void;
+  readonly compactfheint128list_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint256_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint256_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint256_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint256_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint256_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint256_serialize: (a: number, b: number) => void;
+  readonly fheint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compressedfheint256_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint256_serialize: (a: number, b: number) => void;
+  readonly compressedfheint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint256_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint256_expand: (a: number, b: number) => void;
+  readonly compactfheint256_serialize: (a: number, b: number) => void;
+  readonly compactfheint256_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint256_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint256_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint256list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint256list_expand: (a: number, b: number) => void;
+  readonly compactfheint256list_serialize: (a: number, b: number) => void;
+  readonly compactfheint256list_deserialize: (a: number, b: number, c: number) => void;
   readonly fheuint8_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly fheuint8_encrypt_with_public_key: (a: number, b: number, c: number) => void;
   readonly fheuint8_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
@@ -1453,13 +2599,19 @@ export interface InitOutput {
   readonly fheuint8_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint8_serialize: (a: number, b: number) => void;
   readonly fheuint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheuint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint8_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly compressedfheuint8_serialize: (a: number, b: number) => void;
   readonly compressedfheuint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint8_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint8_expand: (a: number, b: number) => void;
   readonly compactfheuint8_serialize: (a: number, b: number) => void;
   readonly compactfheuint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint8list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint8list_expand: (a: number, b: number) => void;
   readonly compactfheuint8list_serialize: (a: number, b: number) => void;
@@ -1471,13 +2623,19 @@ export interface InitOutput {
   readonly fheuint16_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint16_serialize: (a: number, b: number) => void;
   readonly fheuint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheuint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint16_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly compressedfheuint16_serialize: (a: number, b: number) => void;
   readonly compressedfheuint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint16_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint16_expand: (a: number, b: number) => void;
   readonly compactfheuint16_serialize: (a: number, b: number) => void;
   readonly compactfheuint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint16list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint16list_expand: (a: number, b: number) => void;
   readonly compactfheuint16list_serialize: (a: number, b: number) => void;
@@ -1489,13 +2647,19 @@ export interface InitOutput {
   readonly fheuint32_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint32_serialize: (a: number, b: number) => void;
   readonly fheuint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheuint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint32_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly compressedfheuint32_serialize: (a: number, b: number) => void;
   readonly compressedfheuint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint32_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint32_expand: (a: number, b: number) => void;
   readonly compactfheuint32_serialize: (a: number, b: number) => void;
   readonly compactfheuint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint32list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint32list_expand: (a: number, b: number) => void;
   readonly compactfheuint32list_serialize: (a: number, b: number) => void;
@@ -1507,26 +2671,140 @@ export interface InitOutput {
   readonly fheuint64_decrypt: (a: number, b: number, c: number) => void;
   readonly fheuint64_serialize: (a: number, b: number) => void;
   readonly fheuint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheuint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheuint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compressedfheuint64_encrypt_with_client_key: (a: number, b: number, c: number) => void;
   readonly compressedfheuint64_serialize: (a: number, b: number) => void;
   readonly compressedfheuint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheuint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint64_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
   readonly compactfheuint64_expand: (a: number, b: number) => void;
   readonly compactfheuint64_serialize: (a: number, b: number) => void;
   readonly compactfheuint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheuint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint64list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
   readonly compactfheuint64list_expand: (a: number, b: number) => void;
   readonly compactfheuint64list_serialize: (a: number, b: number) => void;
   readonly compactfheuint64list_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint8_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint8_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint8_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint8_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint8_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint8_serialize: (a: number, b: number) => void;
+  readonly fheint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compressedfheint8_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint8_serialize: (a: number, b: number) => void;
+  readonly compressedfheint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint8_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint8_expand: (a: number, b: number) => void;
+  readonly compactfheint8_serialize: (a: number, b: number) => void;
+  readonly compactfheint8_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint8_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint8_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint8list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint8list_expand: (a: number, b: number) => void;
+  readonly compactfheint8list_serialize: (a: number, b: number) => void;
+  readonly compactfheint8list_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint16_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint16_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint16_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint16_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint16_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint16_serialize: (a: number, b: number) => void;
+  readonly fheint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compressedfheint16_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint16_serialize: (a: number, b: number) => void;
+  readonly compressedfheint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint16_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint16_expand: (a: number, b: number) => void;
+  readonly compactfheint16_serialize: (a: number, b: number) => void;
+  readonly compactfheint16_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint16_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint16_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint16list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint16list_expand: (a: number, b: number) => void;
+  readonly compactfheint16list_serialize: (a: number, b: number) => void;
+  readonly compactfheint16list_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint32_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint32_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint32_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint32_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint32_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint32_serialize: (a: number, b: number) => void;
+  readonly fheint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compressedfheint32_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint32_serialize: (a: number, b: number) => void;
+  readonly compressedfheint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint32_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint32_expand: (a: number, b: number) => void;
+  readonly compactfheint32_serialize: (a: number, b: number) => void;
+  readonly compactfheint32_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint32_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint32_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint32list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint32list_expand: (a: number, b: number) => void;
+  readonly compactfheint32list_serialize: (a: number, b: number) => void;
+  readonly compactfheint32list_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint64_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly fheint64_encrypt_with_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint64_encrypt_with_compressed_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint64_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly fheint64_decrypt: (a: number, b: number, c: number) => void;
+  readonly fheint64_serialize: (a: number, b: number) => void;
+  readonly fheint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly fheint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly fheint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compressedfheint64_encrypt_with_client_key: (a: number, b: number, c: number) => void;
+  readonly compressedfheint64_serialize: (a: number, b: number) => void;
+  readonly compressedfheint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compressedfheint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint64_encrypt_with_compact_public_key: (a: number, b: number, c: number) => void;
+  readonly compactfheint64_expand: (a: number, b: number) => void;
+  readonly compactfheint64_serialize: (a: number, b: number) => void;
+  readonly compactfheint64_deserialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint64_safe_serialize: (a: number, b: number, c: number) => void;
+  readonly compactfheint64_safe_deserialize: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint64list_encrypt_with_compact_public_key: (a: number, b: number, c: number, d: number) => void;
+  readonly compactfheint64list_expand: (a: number, b: number) => void;
+  readonly compactfheint64list_serialize: (a: number, b: number) => void;
+  readonly compactfheint64list_deserialize: (a: number, b: number, c: number) => void;
   readonly __wbg_fheuint256_free: (a: number) => void;
+  readonly __wbg_fheuint128_free: (a: number) => void;
+  readonly __wbg_fheint256_free: (a: number) => void;
   readonly __wbg_fheuint8_free: (a: number) => void;
   readonly __wbg_fheuint16_free: (a: number) => void;
   readonly __wbg_fheuint32_free: (a: number) => void;
   readonly __wbg_fheuint64_free: (a: number) => void;
+  readonly __wbg_fheint8_free: (a: number) => void;
+  readonly __wbg_fheint16_free: (a: number) => void;
+  readonly __wbg_fheint32_free: (a: number) => void;
+  readonly __wbg_fheint64_free: (a: number) => void;
   readonly __wbg_compactfheuint128list_free: (a: number) => void;
   readonly __wbg_compressedfheuint256_free: (a: number) => void;
   readonly __wbg_compactfheuint256_free: (a: number) => void;
   readonly __wbg_compactfheuint256list_free: (a: number) => void;
+  readonly __wbg_compressedfheuint128_free: (a: number) => void;
+  readonly __wbg_compactfheuint128_free: (a: number) => void;
+  readonly __wbg_compactfheint128list_free: (a: number) => void;
+  readonly __wbg_compressedfheint256_free: (a: number) => void;
+  readonly __wbg_compactfheint256_free: (a: number) => void;
+  readonly __wbg_compactfheint256list_free: (a: number) => void;
   readonly __wbg_compressedfheuint8_free: (a: number) => void;
   readonly __wbg_compactfheuint8_free: (a: number) => void;
   readonly __wbg_compactfheuint8list_free: (a: number) => void;
@@ -1539,46 +2817,29 @@ export interface InitOutput {
   readonly __wbg_compressedfheuint64_free: (a: number) => void;
   readonly __wbg_compactfheuint64_free: (a: number) => void;
   readonly __wbg_compactfheuint64list_free: (a: number) => void;
+  readonly __wbg_compressedfheint8_free: (a: number) => void;
+  readonly __wbg_compactfheint8_free: (a: number) => void;
+  readonly __wbg_compactfheint8list_free: (a: number) => void;
+  readonly __wbg_compressedfheint16_free: (a: number) => void;
+  readonly __wbg_compactfheint16_free: (a: number) => void;
+  readonly __wbg_compactfheint16list_free: (a: number) => void;
+  readonly __wbg_compressedfheint32_free: (a: number) => void;
+  readonly __wbg_compactfheint32_free: (a: number) => void;
+  readonly __wbg_compactfheint32list_free: (a: number) => void;
+  readonly __wbg_compressedfheint64_free: (a: number) => void;
+  readonly __wbg_compactfheint64_free: (a: number) => void;
+  readonly __wbg_compactfheint64list_free: (a: number) => void;
   readonly compressedfheuint256_decompress: (a: number, b: number) => void;
+  readonly compressedfheuint128_decompress: (a: number, b: number) => void;
+  readonly compressedfheint256_decompress: (a: number, b: number) => void;
   readonly compressedfheuint8_decompress: (a: number, b: number) => void;
   readonly compressedfheuint16_decompress: (a: number, b: number) => void;
   readonly compressedfheuint32_decompress: (a: number, b: number) => void;
   readonly compressedfheuint64_decompress: (a: number, b: number) => void;
-  readonly init_panic_hook: () => void;
-  readonly __wbg_tfheclientkey_free: (a: number) => void;
-  readonly tfheclientkey_generate: (a: number, b: number) => void;
-  readonly tfheclientkey_generate_with_seed: (a: number, b: number, c: number) => void;
-  readonly tfheclientkey_serialize: (a: number, b: number) => void;
-  readonly tfheclientkey_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_tfhecompressedserverkey_free: (a: number) => void;
-  readonly tfhecompressedserverkey_new: (a: number, b: number) => void;
-  readonly tfhecompressedserverkey_serialize: (a: number, b: number) => void;
-  readonly tfhecompressedserverkey_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_tfhepublickey_free: (a: number) => void;
-  readonly tfhepublickey_new: (a: number, b: number) => void;
-  readonly tfhepublickey_serialize: (a: number, b: number) => void;
-  readonly tfhepublickey_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_tfhecompressedpublickey_free: (a: number) => void;
-  readonly tfhecompressedpublickey_new: (a: number, b: number) => void;
-  readonly tfhecompressedpublickey_decompress: (a: number, b: number) => void;
-  readonly tfhecompressedpublickey_serialize: (a: number, b: number) => void;
-  readonly tfhecompressedpublickey_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_tfhecompactpublickey_free: (a: number) => void;
-  readonly tfhecompactpublickey_new: (a: number, b: number) => void;
-  readonly tfhecompactpublickey_serialize: (a: number, b: number) => void;
-  readonly tfhecompactpublickey_deserialize: (a: number, b: number, c: number) => void;
-  readonly __wbg_tfhecompressedcompactpublickey_free: (a: number) => void;
-  readonly tfhecompressedcompactpublickey_new: (a: number, b: number) => void;
-  readonly tfhecompressedcompactpublickey_serialize: (a: number, b: number) => void;
-  readonly tfhecompressedcompactpublickey_deserialize: (a: number, b: number, c: number) => void;
-  readonly tfhecompressedcompactpublickey_decompress: (a: number, b: number) => void;
-  readonly __wbg_tfheconfig_free: (a: number) => void;
-  readonly tfheconfigbuilder_all_disabled: () => number;
-  readonly tfheconfigbuilder_enable_default_integers: (a: number) => number;
-  readonly tfheconfigbuilder_enable_default_integers_small: (a: number) => number;
-  readonly tfheconfigbuilder_enable_custom_integers: (a: number, b: number) => number;
-  readonly tfheconfigbuilder_build: (a: number) => number;
-  readonly __wbg_tfheconfigbuilder_free: (a: number) => void;
+  readonly compressedfheint8_decompress: (a: number, b: number) => void;
+  readonly compressedfheint16_decompress: (a: number, b: number) => void;
+  readonly compressedfheint32_decompress: (a: number, b: number) => void;
+  readonly compressedfheint64_decompress: (a: number, b: number) => void;
   readonly __wbg_shortintciphertext_free: (a: number) => void;
   readonly __wbg_shortintcompressedciphertext_free: (a: number) => void;
   readonly __wbg_shortintclientkey_free: (a: number) => void;
@@ -1613,7 +2874,42 @@ export interface InitOutput {
   readonly shortint_deserialize_compressed_public_key: (a: number, b: number, c: number) => void;
   readonly shortint_serialize_compressed_server_key: (a: number, b: number) => void;
   readonly shortint_deserialize_compressed_server_key: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfheconfig_free: (a: number) => void;
+  readonly tfheconfigbuilder_all_disabled: () => number;
+  readonly tfheconfigbuilder_enable_default_integers: (a: number) => number;
+  readonly tfheconfigbuilder_enable_default_integers_small: (a: number) => number;
+  readonly tfheconfigbuilder_enable_custom_integers: (a: number, b: number) => number;
+  readonly tfheconfigbuilder_build: (a: number) => number;
   readonly __wbg_shortint_free: (a: number) => void;
+  readonly __wbg_tfheconfigbuilder_free: (a: number) => void;
+  readonly init_panic_hook: () => void;
+  readonly __wbg_tfheclientkey_free: (a: number) => void;
+  readonly tfheclientkey_generate: (a: number, b: number) => void;
+  readonly tfheclientkey_generate_with_seed: (a: number, b: number, c: number) => void;
+  readonly tfheclientkey_serialize: (a: number, b: number) => void;
+  readonly tfheclientkey_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfhecompressedserverkey_free: (a: number) => void;
+  readonly tfhecompressedserverkey_new: (a: number, b: number) => void;
+  readonly tfhecompressedserverkey_serialize: (a: number, b: number) => void;
+  readonly tfhecompressedserverkey_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfhepublickey_free: (a: number) => void;
+  readonly tfhepublickey_new: (a: number, b: number) => void;
+  readonly tfhepublickey_serialize: (a: number, b: number) => void;
+  readonly tfhepublickey_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfhecompressedpublickey_free: (a: number) => void;
+  readonly tfhecompressedpublickey_new: (a: number, b: number) => void;
+  readonly tfhecompressedpublickey_decompress: (a: number, b: number) => void;
+  readonly tfhecompressedpublickey_serialize: (a: number, b: number) => void;
+  readonly tfhecompressedpublickey_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfhecompactpublickey_free: (a: number) => void;
+  readonly tfhecompactpublickey_new: (a: number, b: number) => void;
+  readonly tfhecompactpublickey_serialize: (a: number, b: number) => void;
+  readonly tfhecompactpublickey_deserialize: (a: number, b: number, c: number) => void;
+  readonly __wbg_tfhecompressedcompactpublickey_free: (a: number) => void;
+  readonly tfhecompressedcompactpublickey_new: (a: number, b: number) => void;
+  readonly tfhecompressedcompactpublickey_serialize: (a: number, b: number) => void;
+  readonly tfhecompressedcompactpublickey_deserialize: (a: number, b: number, c: number) => void;
+  readonly tfhecompressedcompactpublickey_decompress: (a: number, b: number) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;