tfhe/tfhe.d.ts

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.

/* tslint:disable */
/* eslint-disable */

export class Boolean {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    static decompress_ciphertext(compressed_ciphertext: BooleanCompressedCiphertext): BooleanCiphertext;
    static decrypt(client_key: BooleanClientKey, ct: BooleanCiphertext): boolean;
    static deserialize_ciphertext(buffer: Uint8Array): BooleanCiphertext;
    static deserialize_client_key(buffer: Uint8Array): BooleanClientKey;
    static deserialize_compressed_ciphertext(buffer: Uint8Array): BooleanCompressedCiphertext;
    static deserialize_compressed_server_key(buffer: Uint8Array): BooleanCompressedServerKey;
    static deserialize_public_key(buffer: Uint8Array): BooleanPublicKey;
    static encrypt(client_key: BooleanClientKey, message: boolean): BooleanCiphertext;
    static encrypt_compressed(client_key: BooleanClientKey, message: boolean): BooleanCompressedCiphertext;
    static encrypt_with_public_key(public_key: BooleanPublicKey, message: boolean): BooleanCiphertext;
    static get_parameters(parameter_choice: number): BooleanParameters;
    static new_client_key(parameters: BooleanParameters): BooleanClientKey;
    static new_client_key_from_seed_and_parameters(seed_high_bytes: bigint, seed_low_bytes: bigint, parameters: BooleanParameters): BooleanClientKey;
    static new_compressed_server_key(client_key: BooleanClientKey): BooleanCompressedServerKey;
    static new_gaussian_from_std_dev(std_dev: number): BooleanNoiseDistribution;
    static new_parameters(lwe_dimension: number, glwe_dimension: number, polynomial_size: number, lwe_noise_distribution: BooleanNoiseDistribution, glwe_noise_distribution: BooleanNoiseDistribution, pbs_base_log: number, pbs_level: number, ks_base_log: number, ks_level: number, encryption_key_choice: BooleanEncryptionKeyChoice): BooleanParameters;
    static new_public_key(client_key: BooleanClientKey): BooleanPublicKey;
    static serialize_ciphertext(ciphertext: BooleanCiphertext): Uint8Array;
    static serialize_client_key(client_key: BooleanClientKey): Uint8Array;
    static serialize_compressed_ciphertext(ciphertext: BooleanCompressedCiphertext): Uint8Array;
    static serialize_compressed_server_key(server_key: BooleanCompressedServerKey): Uint8Array;
    static serialize_public_key(public_key: BooleanPublicKey): Uint8Array;
    static trivial_encrypt(message: boolean): BooleanCiphertext;
    static try_new_t_uniform(bound_log2: number): BooleanNoiseDistribution;
}

export class BooleanCiphertext {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export class BooleanClientKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export class BooleanCompressedCiphertext {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export class BooleanCompressedServerKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export enum BooleanEncryptionKeyChoice {
    Big = 0,
    Small = 1,
}

export class BooleanNoiseDistribution {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export enum BooleanParameterSet {
    Default = 0,
    TfheLib = 1,
    DefaultKsPbs = 2,
    TfheLibKsPbs = 3,
}

export class BooleanParameters {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export class BooleanPublicKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
}

export class CompactCiphertextList {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    static builder(public_key: TfheCompactPublicKey): CompactCiphertextListBuilder;
    static deserialize(buffer: Uint8Array): CompactCiphertextList;
    expand(): CompactCiphertextListExpander;
    get_kind_of(index: number): FheTypes | undefined;
    is_empty(): boolean;
    len(): number;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactCiphertextList;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompactCiphertextListBuilder {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    build(): CompactCiphertextList;
    build_packed(): CompactCiphertextList;
    build_with_proof_packed(crs: CompactPkeCrs, metadata: Uint8Array, compute_load: ZkComputeLoad): ProvenCompactCiphertextList;
    push_boolean(value: boolean): void;
    push_i10(value: number): void;
    push_i1024(value: any): void;
    push_i104(value: any): void;
    push_i112(value: any): void;
    push_i12(value: number): void;
    push_i120(value: any): void;
    push_i128(value: any): void;
    push_i136(value: any): void;
    push_i14(value: number): void;
    push_i144(value: any): void;
    push_i152(value: any): void;
    push_i16(value: number): void;
    push_i160(value: any): void;
    push_i168(value: any): void;
    push_i176(value: any): void;
    push_i184(value: any): void;
    push_i192(value: any): void;
    push_i2(value: number): void;
    push_i200(value: any): void;
    push_i2048(value: any): void;
    push_i208(value: any): void;
    push_i216(value: any): void;
    push_i224(value: any): void;
    push_i232(value: any): void;
    push_i24(value: number): void;
    push_i240(value: any): void;
    push_i248(value: any): void;
    push_i256(value: any): void;
    push_i32(value: number): void;
    push_i4(value: number): void;
    push_i40(value: bigint): void;
    push_i48(value: bigint): void;
    push_i512(value: any): void;
    push_i56(value: bigint): void;
    push_i6(value: number): void;
    push_i64(value: bigint): void;
    push_i72(value: any): void;
    push_i8(value: number): void;
    push_i80(value: any): void;
    push_i88(value: any): void;
    push_i96(value: any): void;
    push_u10(value: number): void;
    push_u1024(value: any): void;
    push_u104(value: any): void;
    push_u112(value: any): void;
    push_u12(value: number): void;
    push_u120(value: any): void;
    push_u128(value: any): void;
    push_u136(value: any): void;
    push_u14(value: number): void;
    push_u144(value: any): void;
    push_u152(value: any): void;
    push_u16(value: number): void;
    push_u160(value: any): void;
    push_u168(value: any): void;
    push_u176(value: any): void;
    push_u184(value: any): void;
    push_u192(value: any): void;
    push_u2(value: number): void;
    push_u200(value: any): void;
    push_u2048(value: any): void;
    push_u208(value: any): void;
    push_u216(value: any): void;
    push_u224(value: any): void;
    push_u232(value: any): void;
    push_u24(value: number): void;
    push_u240(value: any): void;
    push_u248(value: any): void;
    push_u256(value: any): void;
    push_u32(value: number): void;
    push_u4(value: number): void;
    push_u40(value: bigint): void;
    push_u48(value: bigint): void;
    push_u512(value: any): void;
    push_u56(value: bigint): void;
    push_u6(value: number): void;
    push_u64(value: bigint): void;
    push_u72(value: any): void;
    push_u8(value: number): void;
    push_u80(value: any): void;
    push_u88(value: any): void;
    push_u96(value: any): void;
}

export class CompactCiphertextListExpander {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    get_bool(index: number): FheBool;
    get_int10(index: number): FheInt10;
    get_int1024(index: number): FheInt1024;
    get_int104(index: number): FheInt104;
    get_int112(index: number): FheInt112;
    get_int12(index: number): FheInt12;
    get_int120(index: number): FheInt120;
    get_int128(index: number): FheInt128;
    get_int136(index: number): FheInt136;
    get_int14(index: number): FheInt14;
    get_int144(index: number): FheInt144;
    get_int152(index: number): FheInt152;
    get_int16(index: number): FheInt16;
    get_int160(index: number): FheInt160;
    get_int168(index: number): FheInt168;
    get_int176(index: number): FheInt176;
    get_int184(index: number): FheInt184;
    get_int192(index: number): FheInt192;
    get_int2(index: number): FheInt2;
    get_int200(index: number): FheInt200;
    get_int2048(index: number): FheInt2048;
    get_int208(index: number): FheInt208;
    get_int216(index: number): FheInt216;
    get_int224(index: number): FheInt224;
    get_int232(index: number): FheInt232;
    get_int24(index: number): FheInt24;
    get_int240(index: number): FheInt240;
    get_int248(index: number): FheInt248;
    get_int256(index: number): FheInt256;
    get_int32(index: number): FheInt32;
    get_int4(index: number): FheInt4;
    get_int40(index: number): FheInt40;
    get_int48(index: number): FheInt48;
    get_int512(index: number): FheInt512;
    get_int56(index: number): FheInt56;
    get_int6(index: number): FheInt6;
    get_int64(index: number): FheInt64;
    get_int72(index: number): FheInt72;
    get_int8(index: number): FheInt8;
    get_int80(index: number): FheInt80;
    get_int88(index: number): FheInt88;
    get_int96(index: number): FheInt96;
    get_kind_of(index: number): FheTypes | undefined;
    get_uint10(index: number): FheUint10;
    get_uint1024(index: number): FheUint1024;
    get_uint104(index: number): FheUint104;
    get_uint112(index: number): FheUint112;
    get_uint12(index: number): FheUint12;
    get_uint120(index: number): FheUint120;
    get_uint128(index: number): FheUint128;
    get_uint136(index: number): FheUint136;
    get_uint14(index: number): FheUint14;
    get_uint144(index: number): FheUint144;
    get_uint152(index: number): FheUint152;
    get_uint16(index: number): FheUint16;
    get_uint160(index: number): FheUint160;
    get_uint168(index: number): FheUint168;
    get_uint176(index: number): FheUint176;
    get_uint184(index: number): FheUint184;
    get_uint192(index: number): FheUint192;
    get_uint2(index: number): FheUint2;
    get_uint200(index: number): FheUint200;
    get_uint2048(index: number): FheUint2048;
    get_uint208(index: number): FheUint208;
    get_uint216(index: number): FheUint216;
    get_uint224(index: number): FheUint224;
    get_uint232(index: number): FheUint232;
    get_uint24(index: number): FheUint24;
    get_uint240(index: number): FheUint240;
    get_uint248(index: number): FheUint248;
    get_uint256(index: number): FheUint256;
    get_uint32(index: number): FheUint32;
    get_uint4(index: number): FheUint4;
    get_uint40(index: number): FheUint40;
    get_uint48(index: number): FheUint48;
    get_uint512(index: number): FheUint512;
    get_uint56(index: number): FheUint56;
    get_uint6(index: number): FheUint6;
    get_uint64(index: number): FheUint64;
    get_uint72(index: number): FheUint72;
    get_uint8(index: number): FheUint8;
    get_uint80(index: number): FheUint80;
    get_uint88(index: number): FheUint88;
    get_uint96(index: number): FheUint96;
    is_empty(): boolean;
    len(): number;
}

export class CompactPkeCrs {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    static deserialize(buffer: Uint8Array): CompactPkeCrs;
    static deserialize_from_public_params(buffer: Uint8Array): CompactPkeCrs;
    static from_config(config: TfheConfig, max_num_bits: number): CompactPkeCrs;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompactPkeCrs;
    static safe_deserialize_from_public_params(buffer: Uint8Array, serialized_size_limit: bigint): CompactPkeCrs;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(compress: boolean): Uint8Array;
}

export class CompressedFheBool {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheBool;
    static deserialize(buffer: Uint8Array): CompressedFheBool;
    static encrypt_with_client_key(value: boolean, client_key: TfheClientKey): CompressedFheBool;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheBool;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt10 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt10;
    static deserialize(buffer: Uint8Array): CompressedFheInt10;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt10;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt10;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt1024 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt1024;
    static deserialize(buffer: Uint8Array): CompressedFheInt1024;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt1024;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt1024;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt104 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt104;
    static deserialize(buffer: Uint8Array): CompressedFheInt104;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt104;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt104;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt112 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt112;
    static deserialize(buffer: Uint8Array): CompressedFheInt112;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt112;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt112;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt12 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt12;
    static deserialize(buffer: Uint8Array): CompressedFheInt12;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt12;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt12;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt120 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt120;
    static deserialize(buffer: Uint8Array): CompressedFheInt120;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt120;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt120;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt128 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt128;
    static deserialize(buffer: Uint8Array): CompressedFheInt128;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt128;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt128;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt136 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt136;
    static deserialize(buffer: Uint8Array): CompressedFheInt136;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt136;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt136;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt14 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt14;
    static deserialize(buffer: Uint8Array): CompressedFheInt14;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt14;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt14;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt144 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt144;
    static deserialize(buffer: Uint8Array): CompressedFheInt144;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt144;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt144;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt152 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt152;
    static deserialize(buffer: Uint8Array): CompressedFheInt152;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt152;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt152;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt16 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt16;
    static deserialize(buffer: Uint8Array): CompressedFheInt16;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt16;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt16;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt160 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt160;
    static deserialize(buffer: Uint8Array): CompressedFheInt160;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt160;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt160;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt168 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt168;
    static deserialize(buffer: Uint8Array): CompressedFheInt168;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt168;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt168;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt176 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt176;
    static deserialize(buffer: Uint8Array): CompressedFheInt176;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt176;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt176;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt184 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt184;
    static deserialize(buffer: Uint8Array): CompressedFheInt184;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt184;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt184;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt192 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt192;
    static deserialize(buffer: Uint8Array): CompressedFheInt192;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt192;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt192;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt2 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt2;
    static deserialize(buffer: Uint8Array): CompressedFheInt2;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt2;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt2;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt200 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt200;
    static deserialize(buffer: Uint8Array): CompressedFheInt200;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt200;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt200;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt2048 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt2048;
    static deserialize(buffer: Uint8Array): CompressedFheInt2048;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt2048;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt2048;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt208 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt208;
    static deserialize(buffer: Uint8Array): CompressedFheInt208;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt208;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt208;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt216 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt216;
    static deserialize(buffer: Uint8Array): CompressedFheInt216;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt216;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt216;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt224 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt224;
    static deserialize(buffer: Uint8Array): CompressedFheInt224;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt224;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt224;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt232 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt232;
    static deserialize(buffer: Uint8Array): CompressedFheInt232;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt232;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt232;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt24 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt24;
    static deserialize(buffer: Uint8Array): CompressedFheInt24;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt24;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt24;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt240 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt240;
    static deserialize(buffer: Uint8Array): CompressedFheInt240;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt240;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt240;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt248 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt248;
    static deserialize(buffer: Uint8Array): CompressedFheInt248;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt248;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt248;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt256 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt256;
    static deserialize(buffer: Uint8Array): CompressedFheInt256;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt256;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt256;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt32 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt32;
    static deserialize(buffer: Uint8Array): CompressedFheInt32;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt32;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt32;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt4 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt4;
    static deserialize(buffer: Uint8Array): CompressedFheInt4;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt4;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt4;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt40 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt40;
    static deserialize(buffer: Uint8Array): CompressedFheInt40;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheInt40;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt40;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt48 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt48;
    static deserialize(buffer: Uint8Array): CompressedFheInt48;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheInt48;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt48;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt512 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt512;
    static deserialize(buffer: Uint8Array): CompressedFheInt512;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt512;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt512;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt56 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt56;
    static deserialize(buffer: Uint8Array): CompressedFheInt56;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheInt56;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt56;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt6 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt6;
    static deserialize(buffer: Uint8Array): CompressedFheInt6;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt6;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt6;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt64 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt64;
    static deserialize(buffer: Uint8Array): CompressedFheInt64;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheInt64;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt64;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt72 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt72;
    static deserialize(buffer: Uint8Array): CompressedFheInt72;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt72;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt72;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt8 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt8;
    static deserialize(buffer: Uint8Array): CompressedFheInt8;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheInt8;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt8;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt80 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt80;
    static deserialize(buffer: Uint8Array): CompressedFheInt80;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt80;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt80;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt88 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt88;
    static deserialize(buffer: Uint8Array): CompressedFheInt88;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt88;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt88;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheInt96 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheInt96;
    static deserialize(buffer: Uint8Array): CompressedFheInt96;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheInt96;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheInt96;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint10 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint10;
    static deserialize(buffer: Uint8Array): CompressedFheUint10;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint10;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint10;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint1024 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint1024;
    static deserialize(buffer: Uint8Array): CompressedFheUint1024;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint1024;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint1024;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint104 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint104;
    static deserialize(buffer: Uint8Array): CompressedFheUint104;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint104;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint104;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint112 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint112;
    static deserialize(buffer: Uint8Array): CompressedFheUint112;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint112;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint112;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint12 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint12;
    static deserialize(buffer: Uint8Array): CompressedFheUint12;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint12;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint12;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint120 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint120;
    static deserialize(buffer: Uint8Array): CompressedFheUint120;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint120;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint120;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint128 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint128;
    static deserialize(buffer: Uint8Array): CompressedFheUint128;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint128;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint128;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint136 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint136;
    static deserialize(buffer: Uint8Array): CompressedFheUint136;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint136;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint136;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint14 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint14;
    static deserialize(buffer: Uint8Array): CompressedFheUint14;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint14;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint14;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint144 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint144;
    static deserialize(buffer: Uint8Array): CompressedFheUint144;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint144;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint144;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint152 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint152;
    static deserialize(buffer: Uint8Array): CompressedFheUint152;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint152;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint152;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint16 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint16;
    static deserialize(buffer: Uint8Array): CompressedFheUint16;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint16;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint16;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint160 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint160;
    static deserialize(buffer: Uint8Array): CompressedFheUint160;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint160;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint160;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint168 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint168;
    static deserialize(buffer: Uint8Array): CompressedFheUint168;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint168;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint168;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint176 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint176;
    static deserialize(buffer: Uint8Array): CompressedFheUint176;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint176;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint176;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint184 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint184;
    static deserialize(buffer: Uint8Array): CompressedFheUint184;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint184;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint184;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint192 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint192;
    static deserialize(buffer: Uint8Array): CompressedFheUint192;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint192;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint192;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint2 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint2;
    static deserialize(buffer: Uint8Array): CompressedFheUint2;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint2;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint2;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint200 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint200;
    static deserialize(buffer: Uint8Array): CompressedFheUint200;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint200;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint200;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint2048 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint2048;
    static deserialize(buffer: Uint8Array): CompressedFheUint2048;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint2048;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint2048;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint208 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint208;
    static deserialize(buffer: Uint8Array): CompressedFheUint208;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint208;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint208;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint216 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint216;
    static deserialize(buffer: Uint8Array): CompressedFheUint216;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint216;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint216;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint224 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint224;
    static deserialize(buffer: Uint8Array): CompressedFheUint224;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint224;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint224;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint232 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint232;
    static deserialize(buffer: Uint8Array): CompressedFheUint232;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint232;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint232;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint24 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint24;
    static deserialize(buffer: Uint8Array): CompressedFheUint24;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint24;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint24;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint240 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint240;
    static deserialize(buffer: Uint8Array): CompressedFheUint240;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint240;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint240;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint248 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint248;
    static deserialize(buffer: Uint8Array): CompressedFheUint248;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint248;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint248;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint256 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint256;
    static deserialize(buffer: Uint8Array): CompressedFheUint256;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint256;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint256;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint32 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint32;
    static deserialize(buffer: Uint8Array): CompressedFheUint32;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint32;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint32;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint4 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint4;
    static deserialize(buffer: Uint8Array): CompressedFheUint4;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint4;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint4;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint40 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint40;
    static deserialize(buffer: Uint8Array): CompressedFheUint40;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheUint40;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint40;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint48 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint48;
    static deserialize(buffer: Uint8Array): CompressedFheUint48;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheUint48;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint48;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint512 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint512;
    static deserialize(buffer: Uint8Array): CompressedFheUint512;
    static encrypt_with_client_key(value: any, client_key: TfheClientKey): CompressedFheUint512;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint512;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint56 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint56;
    static deserialize(buffer: Uint8Array): CompressedFheUint56;
    static encrypt_with_client_key(value: bigint, client_key: TfheClientKey): CompressedFheUint56;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint56;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint6 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint6;
    static deserialize(buffer: Uint8Array): CompressedFheUint6;
    static encrypt_with_client_key(value: number, client_key: TfheClientKey): CompressedFheUint6;
    static safe_deserialize(buffer: Uint8Array, serialized_size_limit: bigint): CompressedFheUint6;
    safe_serialize(serialized_size_limit: bigint): Uint8Array;
    serialize(): Uint8Array;
}

export class CompressedFheUint64 {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    decompress(): FheUint64;
    static deserialize(buffer